From 0e3fc228cc5ec089849b6bcabb3c927875aa760c Mon Sep 17 00:00:00 2001 From: Brendan Lee Date: Tue, 28 Nov 2017 12:13:14 -0800 Subject: [PATCH 1/2] Updated lib for 0.7.0 release --- Samples/DataSources/datasources.html | 4 +- Samples/Filtering/filtering.html | 2 +- Samples/Parameters/parameters.html | 2 +- Samples/Settings/settings.html | 2 +- .../tableau-extensions-0.6.1.js | 0 lib/tableau-extensions-0.7.0.js | 24229 ++++++++++++++++ 6 files changed, 24234 insertions(+), 5 deletions(-) rename lib/{ => previous}/tableau-extensions-0.6.1.js (100%) create mode 100644 lib/tableau-extensions-0.7.0.js diff --git a/Samples/DataSources/datasources.html b/Samples/DataSources/datasources.html index efd3bfba..837fa47f 100644 --- a/Samples/DataSources/datasources.html +++ b/Samples/DataSources/datasources.html @@ -15,7 +15,7 @@ - + @@ -67,7 +67,7 @@

DataSource Details

Type - + Fields diff --git a/Samples/Filtering/filtering.html b/Samples/Filtering/filtering.html index 1e960820..3d523fbc 100644 --- a/Samples/Filtering/filtering.html +++ b/Samples/Filtering/filtering.html @@ -15,7 +15,7 @@ - + diff --git a/Samples/Parameters/parameters.html b/Samples/Parameters/parameters.html index d34cb08d..d6d9fb14 100644 --- a/Samples/Parameters/parameters.html +++ b/Samples/Parameters/parameters.html @@ -15,7 +15,7 @@ - + diff --git a/Samples/Settings/settings.html b/Samples/Settings/settings.html index b0d0f18a..a50c07cf 100644 --- a/Samples/Settings/settings.html +++ b/Samples/Settings/settings.html @@ -14,7 +14,7 @@ - + diff --git a/lib/tableau-extensions-0.6.1.js b/lib/previous/tableau-extensions-0.6.1.js similarity index 100% rename from lib/tableau-extensions-0.6.1.js rename to lib/previous/tableau-extensions-0.6.1.js diff --git a/lib/tableau-extensions-0.7.0.js b/lib/tableau-extensions-0.7.0.js new file mode 100644 index 00000000..18210722 --- /dev/null +++ b/lib/tableau-extensions-0.7.0.js @@ -0,0 +1,24229 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else if(typeof exports === 'object') + exports["Main"] = factory(); + else + root["Main"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.loaded = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/dist/"; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var tableau = __webpack_require__(1); + var FrelardDesktopBootstrap_1 = __webpack_require__(76); + // This Main function will be executed when this module is loaded. Attempt to do our + // bootstrapping with qt and log any errors we encounter + FrelardDesktopBootstrap_1.doBootstrap().catch(function (e) { + console.log('Desktop bootstrapping failed: ' + e); + }); + window.tableau = tableau; + + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + // Due to the way we configured webpack, we should be exporting things which will be under + // a global variable called "tableau". Export everything we want to be visible under tableau + // from this file. + var ExtensionsImpl_1 = __webpack_require__(2); + var Extensions_1 = __webpack_require__(74); + var api_shared_1 = __webpack_require__(9); + api_shared_1.VersionNumber.SetVersionNumber(("0.7.0")); + var extensionImpl = new ExtensionsImpl_1.ExtensionsImpl(); + exports.extensions = new Extensions_1.Extensions(extensionImpl); + // Export Enums + // These show up under the tableau object. I.e. tableau.ExtensionContext.Server + var api_external_contract_1 = __webpack_require__(75); + exports.ExtensionContext = api_external_contract_1.ExtensionContext; + exports.ExtensionMode = api_external_contract_1.ExtensionMode; + exports.AnalyticsObjectType = api_external_contract_1.AnalyticsObjectType; + exports.ColumnType = api_external_contract_1.ColumnType; + exports.DashboardObjectType = api_external_contract_1.DashboardObjectType; + exports.DataType = api_external_contract_1.DataType; + exports.DateRangeType = api_external_contract_1.DateRangeType; + exports.DialogEventType = api_external_contract_1.DialogEventType; + exports.EncodingType = api_external_contract_1.EncodingType; + exports.ErrorCodes = api_external_contract_1.ErrorCodes; + exports.FieldAggregationType = api_external_contract_1.FieldAggregationType; + exports.FieldRoleType = api_external_contract_1.FieldRoleType; + exports.FilterDomainType = api_external_contract_1.FilterDomainType; + exports.FilterType = api_external_contract_1.FilterType; + exports.FilterUpdateType = api_external_contract_1.FilterUpdateType; + exports.FilterNullOption = api_external_contract_1.FilterNullOption; + exports.MarkType = api_external_contract_1.MarkType; + exports.ParameterValueType = api_external_contract_1.ParameterValueType; + exports.PeriodType = api_external_contract_1.PeriodType; + exports.QuickTableCalcType = api_external_contract_1.QuickTableCalcType; + exports.SelectionUpdateType = api_external_contract_1.SelectionUpdateType; + exports.SheetType = api_external_contract_1.SheetType; + exports.SortDirection = api_external_contract_1.SortDirection; + exports.TableauEventType = api_external_contract_1.TableauEventType; + exports.TrendLineModelType = api_external_contract_1.TrendLineModelType; + + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(3); + var api_shared_1 = __webpack_require__(9); + var api_utils_1 = __webpack_require__(66); + var DashboardContent_1 = __webpack_require__(67); + var Environment_1 = __webpack_require__(68); + var Settings_1 = __webpack_require__(69); + var RegisterAllExtensionsServices_1 = __webpack_require__(70); + var SettingsImpl_1 = __webpack_require__(73); + var ExtensionsImpl = (function () { + function ExtensionsImpl() { + } + ExtensionsImpl.prototype.initializeAsync = function () { + var _this = this; + if (!this._initializationPromise) { + this._initializationPromise = new Promise(function (resolve, reject) { + // First thing we want to do is check to see if there is a desktop dispatcher already registered for us + if (api_internal_contract_1.InternalApiDispatcherHolder.hasDesktopApiDispatcherPromise()) { + // Running in desktop, use this promise + var desktopDispatcherPromise = api_internal_contract_1.InternalApiDispatcherHolder.getDesktopDispatcherPromise(); + desktopDispatcherPromise.then(_this.onDispatcherReceived.bind(_this)).then(function () { resolve(); }); + } + else { + // We must be running in server, so we should try to kick of the server dispatcher bootstrapping + api_shared_1.doCrossFrameBootstrap(window, api_shared_1.VersionNumber.Instance).then(_this.onDispatcherReceived.bind(_this)).then(function () { resolve(); }); + } + }); + } + return this._initializationPromise; + }; + ExtensionsImpl.prototype.onDispatcherReceived = function (dispatcher) { + var _this = this; + dispatcher.setVersionNumber(api_shared_1.VersionNumber.Instance); + // Call to register all the services which will use the newly initialized dispatcher + api_shared_1.registerAllSharedServices(dispatcher); + RegisterAllExtensionsServices_1.registerAllExtensionsServices(dispatcher); + // Get the initialization service and initialize this extension + var initializationService = api_shared_1.ApiServiceRegistry.instance.getService("InitializationService" /* InitializationService */); + return initializationService.initializeDashboardExtensionsAsync().then(function (result) { + if (!result.extensionInstance.locator.dashboardPath) { + throw api_utils_1.TableauException.isUndefined(['DashboardPath']); + } + _this.dashboardContent = _this.initializeDashboardContent(result.extensionDashboardInfo, result.extensionInstance.locator.dashboardPath); + _this.environment = new Environment_1.Environment(result.extensionEnvironment); + _this.settings = _this.initializeSettings(result.extensionSettingsInfo); + }); + }; + ExtensionsImpl.prototype.initializeDashboardContent = function (info, sheetPath) { + var dashboardImpl = new api_shared_1.DashboardImpl(info, sheetPath); + var dashboard = new api_shared_1.Dashboard(dashboardImpl); + return new DashboardContent_1.DashboardContent(dashboard); + }; + ExtensionsImpl.prototype.initializeSettings = function (settingsInfo) { + var settingsImpl = new SettingsImpl_1.SettingsImpl(settingsInfo); + return new Settings_1.Settings(settingsImpl); + }; + return ExtensionsImpl; + }()); + exports.ExtensionsImpl = ExtensionsImpl; + + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(4)); + __export(__webpack_require__(5)); + __export(__webpack_require__(6)); + __export(__webpack_require__(7)); + __export(__webpack_require__(8)); + + +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var ExtensionContext; + (function (ExtensionContext) { + ExtensionContext["Desktop"] = "desktop"; + ExtensionContext["Server"] = "server"; + ExtensionContext["Unknown"] = "unknown"; + })(ExtensionContext = exports.ExtensionContext || (exports.ExtensionContext = {})); + var ExtensionMode; + (function (ExtensionMode) { + ExtensionMode["Authoring"] = "authoring"; + ExtensionMode["Viewing"] = "viewing"; + ExtensionMode["Unknown"] = "unknown"; + })(ExtensionMode = exports.ExtensionMode || (exports.ExtensionMode = {})); + var ColumnType; + (function (ColumnType) { + ColumnType["Discrete"] = "discrete"; + ColumnType["Continuous"] = "continuous"; + })(ColumnType = exports.ColumnType || (exports.ColumnType = {})); + var DashboardObjectType; + (function (DashboardObjectType) { + DashboardObjectType["Blank"] = "blank"; + DashboardObjectType["Worksheet"] = "worksheet"; + DashboardObjectType["QuickFilter"] = "quick-filter"; + DashboardObjectType["ParameterControl"] = "parameter-control"; + DashboardObjectType["PageFilter"] = "page-filter"; + DashboardObjectType["Legend"] = "legend"; + DashboardObjectType["Title"] = "title"; + DashboardObjectType["Text"] = "text"; + DashboardObjectType["Image"] = "image"; + DashboardObjectType["WebPage"] = "web-page"; + DashboardObjectType["Extension"] = "extension"; + })(DashboardObjectType = exports.DashboardObjectType || (exports.DashboardObjectType = {})); + var DataType; + (function (DataType) { + DataType["String"] = "string"; + DataType["Int"] = "int"; + DataType["Float"] = "float"; + DataType["Bool"] = "bool"; + DataType["Date"] = "date"; + DataType["DateTime"] = "date-time"; + DataType["Spatial"] = "spatial"; + })(DataType = exports.DataType || (exports.DataType = {})); + var EncodedDataType; + (function (EncodedDataType) { + EncodedDataType["Number"] = "number"; + EncodedDataType["String"] = "string"; + EncodedDataType["Date"] = "date"; + EncodedDataType["Boolean"] = "boolean"; + })(EncodedDataType = exports.EncodedDataType || (exports.EncodedDataType = {})); + var ErrorCode; + (function (ErrorCode) { + ErrorCode["ServerError"] = "server-error"; + ErrorCode["InvalidAggregationFieldName"] = "invalid-aggregation-field-name"; + ErrorCode["InvalidFilterFieldName"] = "invalid-filter-fieldname"; + ErrorCode["InvalidFilterFieldValue"] = "invalid-filter-field-value"; + })(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {})); + var FieldAggregationType; + (function (FieldAggregationType) { + FieldAggregationType["Sum"] = "sum"; + FieldAggregationType["Avg"] = "avg"; + FieldAggregationType["Min"] = "min"; + FieldAggregationType["Max"] = "max"; + FieldAggregationType["Stdev"] = "stdev"; + FieldAggregationType["Stdevp"] = "stdevp"; + FieldAggregationType["Var"] = "var"; + FieldAggregationType["Varp"] = "varp"; + FieldAggregationType["Count"] = "count"; + FieldAggregationType["Countd"] = "countd"; + FieldAggregationType["Median"] = "median"; + FieldAggregationType["Attr"] = "attr"; + FieldAggregationType["None"] = "none"; + FieldAggregationType["Year"] = "year"; + FieldAggregationType["Qtr"] = "qtr"; + FieldAggregationType["Month"] = "month"; + FieldAggregationType["Day"] = "day"; + FieldAggregationType["Hour"] = "hour"; + FieldAggregationType["Minute"] = "minute"; + FieldAggregationType["Second"] = "second"; + FieldAggregationType["Week"] = "week"; + FieldAggregationType["Weekday"] = "weekday"; + FieldAggregationType["MonthYear"] = "month-year"; + FieldAggregationType["Mdy"] = "mdy"; + FieldAggregationType["End"] = "end"; + FieldAggregationType["TruncYear"] = "trunc-year"; + FieldAggregationType["TruncQtr"] = "trunc-qtr"; + FieldAggregationType["TruncMonth"] = "trunc-month"; + FieldAggregationType["TruncWeek"] = "trunc-week"; + FieldAggregationType["TruncDay"] = "trunc-day"; + FieldAggregationType["TruncHour"] = "trunc-hour"; + FieldAggregationType["TruncMinute"] = "trunc-minute"; + FieldAggregationType["TruncSecond"] = "trunc-second"; + FieldAggregationType["Quart1"] = "quart1"; + FieldAggregationType["Quart3"] = "quart3"; + FieldAggregationType["Skewness"] = "skewness"; + FieldAggregationType["Kurtosis"] = "kurtosis"; + FieldAggregationType["InOut"] = "in-out"; + FieldAggregationType["User"] = "user"; + })(FieldAggregationType = exports.FieldAggregationType || (exports.FieldAggregationType = {})); + var FieldRoleType; + (function (FieldRoleType) { + FieldRoleType["Dimension"] = "dimension"; + FieldRoleType["Measure"] = "measure"; + FieldRoleType["Unknown"] = "unknown"; + })(FieldRoleType = exports.FieldRoleType || (exports.FieldRoleType = {})); + /** + * The different update types for applying filter. + */ + var FilterUpdateType; + (function (FilterUpdateType) { + FilterUpdateType["Add"] = "add"; + FilterUpdateType["All"] = "all"; + FilterUpdateType["Replace"] = "replace"; + FilterUpdateType["Remove"] = "remove"; + })(FilterUpdateType = exports.FilterUpdateType || (exports.FilterUpdateType = {})); + var SheetType; + (function (SheetType) { + SheetType["Dashboard"] = "dashboard"; + SheetType["Story"] = "story"; + SheetType["Worksheet"] = "worksheet"; + })(SheetType = exports.SheetType || (exports.SheetType = {})); + var DomainRestrictionType; + (function (DomainRestrictionType) { + DomainRestrictionType["All"] = "all"; + DomainRestrictionType["List"] = "list"; + DomainRestrictionType["Range"] = "range"; + })(DomainRestrictionType = exports.DomainRestrictionType || (exports.DomainRestrictionType = {})); + var DateStepPeriod; + (function (DateStepPeriod) { + DateStepPeriod["Years"] = "years"; + DateStepPeriod["Quarters"] = "quarters"; + DateStepPeriod["Months"] = "months"; + DateStepPeriod["Weeks"] = "weeks"; + DateStepPeriod["Days"] = "days"; + DateStepPeriod["Hours"] = "hours"; + DateStepPeriod["Minutes"] = "minutes"; + DateStepPeriod["Seconds"] = "seconds"; + })(DateStepPeriod = exports.DateStepPeriod || (exports.DateStepPeriod = {})); + /** + * The option for specifying which values to include for filtering. + */ + var FilterNullOption; + (function (FilterNullOption) { + FilterNullOption["NullValues"] = "nullvalues"; + FilterNullOption["NonNullValues"] = "nonnullvalues"; + FilterNullOption["AllValues"] = "allvalues"; + })(FilterNullOption = exports.FilterNullOption || (exports.FilterNullOption = {})); + /** + * The type of filter domain + */ + var FilterDomainType; + (function (FilterDomainType) { + FilterDomainType["Relevant"] = "relevant"; + FilterDomainType["Database"] = "database"; + })(FilterDomainType = exports.FilterDomainType || (exports.FilterDomainType = {})); + /** + * Internal enum for specifying the selection type for select marks api. + */ + var SelectionUpdateType; + (function (SelectionUpdateType) { + SelectionUpdateType["Replace"] = "select-replace"; + SelectionUpdateType["Add"] = "select-add"; + SelectionUpdateType["Remove"] = "select-remove"; + })(SelectionUpdateType = exports.SelectionUpdateType || (exports.SelectionUpdateType = {})); + /** + * Internal enum for specifying the included values type for range selection. + */ + var QuantitativeIncludedValues; + (function (QuantitativeIncludedValues) { + QuantitativeIncludedValues["IncludeNull"] = "include-null"; + QuantitativeIncludedValues["IncludeNonNull"] = "include-non-null"; + QuantitativeIncludedValues["IncludeAll"] = "include-all"; + })(QuantitativeIncludedValues = exports.QuantitativeIncludedValues || (exports.QuantitativeIncludedValues = {})); + /** + * Type of mark for a given marks card in a viz. + */ + var MarkType; + (function (MarkType) { + MarkType["Bar"] = "bar"; + MarkType["Line"] = "line"; + MarkType["Area"] = "area"; + MarkType["Square"] = "square"; + MarkType["Circle"] = "circle"; + MarkType["Shape"] = "shape"; + MarkType["Text"] = "text"; + MarkType["Map"] = "map"; + MarkType["Pie"] = "pie"; + MarkType["GanttBar"] = "gantt-bar"; + MarkType["Polygon"] = "polygon"; + })(MarkType = exports.MarkType || (exports.MarkType = {})); + /** + * Internal enum for specifying the type of filter + */ + var FilterType; + (function (FilterType) { + FilterType["Categorical"] = "categorical"; + FilterType["Range"] = "range"; + FilterType["RelativeDate"] = "relativeDate"; + FilterType["Hierarchical"] = "hierarchical"; + })(FilterType = exports.FilterType || (exports.FilterType = {})); + /** + * Internal enum for specifying the DateRangeType of a relative date filter + */ + var DateRangeType; + (function (DateRangeType) { + /** + * Refers to the last day, week, month, etc. of the date period. + */ + DateRangeType["Last"] = "last"; + /** + * Refers to the last N days, weeks, months, etc. of the date period. + */ + DateRangeType["LastN"] = "lastN"; + /** + * Refers to the next day, week, month, etc. of the date period. + */ + DateRangeType["Next"] = "next"; + /** + * Refers to the next N days, weeks, months, etc. of the date period. + */ + DateRangeType["NextN"] = "nextN"; + /** + * Refers to the current day, week, month, etc. of the date period. + */ + DateRangeType["Current"] = "current"; + /** + * Refers to everything up to and including the current day, week, month, etc. of the date period. + */ + DateRangeType["ToDate"] = "toDate"; + })(DateRangeType = exports.DateRangeType || (exports.DateRangeType = {})); + + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var InternalApiDispatcherHolder; + (function (InternalApiDispatcherHolder) { + function getDesktopDispatcherPromise() { + return window.__tableauDesktopDispatcher; + } + InternalApiDispatcherHolder.getDesktopDispatcherPromise = getDesktopDispatcherPromise; + function hasDesktopApiDispatcherPromise() { + return !!InternalApiDispatcherHolder.getDesktopDispatcherPromise(); + } + InternalApiDispatcherHolder.hasDesktopApiDispatcherPromise = hasDesktopApiDispatcherPromise; + function setDesktopDispatcherPromise(dispatcher) { + window.__tableauDesktopDispatcher = dispatcher; + } + InternalApiDispatcherHolder.setDesktopDispatcherPromise = setDesktopDispatcherPromise; + })(InternalApiDispatcherHolder = exports.InternalApiDispatcherHolder || (exports.InternalApiDispatcherHolder = {})); + + +/***/ }, +/* 6 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var NotificationId; + (function (NotificationId) { + NotificationId["SelectedMarksChanged"] = "selected-marks-changed"; + NotificationId["ParameterChanged"] = "parameter-changed"; + NotificationId["FilterChanged"] = "filter-changed"; + })(NotificationId = exports.NotificationId || (exports.NotificationId = {})); + + +/***/ }, +/* 7 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var ParameterId; + (function (ParameterId) { + ParameterId["ExtensionLocator"] = "extension-locator"; + ParameterId["ExtensionBootstrapInfo"] = "extension-bootstrap-info"; + ParameterId["ExtensionSettingsInfo"] = "extension-settings-info"; + ParameterId["VisualId"] = "visual-id"; + ParameterId["SheetPath"] = "sheet-path"; + ParameterId["IgnoreAliases"] = "ignore-aliases"; + ParameterId["IgnoreSelection"] = "ignore-selection"; + ParameterId["IncludeAllColumns"] = "include-all-columns"; + ParameterId["MaxRows"] = "max-rows"; + ParameterId["UnderlyingDataTable"] = "underlying-data-table"; + ParameterId["UnderlyingSummaryDataTable"] = "underlying-summary-data-table"; + ParameterId["DataSourceDataTable"] = "data-source-data-table"; + ParameterId["SettingsValues"] = "settings-values"; + ParameterId["SelectedData"] = "selected-data"; + ParameterId["HighlightedData"] = "highlighted-data"; + // Filter Params + ParameterId["FieldName"] = "field-name"; + ParameterId["FilterValues"] = "filter-values"; + ParameterId["FilterUpdateType"] = "filter-update-type"; + ParameterId["IsExcludeMode"] = "is-exclude"; + ParameterId["FilterRangeMin"] = "filter-range-min"; + ParameterId["FilterRangeMax"] = "filter-range-max"; + ParameterId["FilterRangeNullOption"] = "filter-range-null-option"; + ParameterId["WorksheetFilters"] = "worksheet-filters"; + ParameterId["FieldId"] = "field-id"; + ParameterId["DomainType"] = "domain-type"; + ParameterId["CategoricalDomain"] = "categorical-domain"; + ParameterId["QuantitativeDomain"] = "quantitative-dmain"; + ParameterId["WorksheetName"] = "worksheet-name"; + ParameterId["DashboardName"] = "dashboard"; + ParameterId["ParameterInfo"] = "parameter-info"; + ParameterId["ParameterInfos"] = "parameter-infos"; + ParameterId["ParameterCaption"] = "paremeter-caption"; + ParameterId["ParameterFieldName"] = "parameter-field-name"; + ParameterId["ParameterValue"] = "parameter-value"; + ParameterId["Selection"] = "selection"; + ParameterId["SelectionUpdateType"] = "selectionUpdateType"; + ParameterId["HierValSelectionModels"] = "hierarchicalValueSelectionModels"; + ParameterId["QuantRangeSelectionModels"] = "quantativeRangeSelectionModels"; + ParameterId["DimValSelectionModels"] = "dimensionValueSelectionModels"; + ParameterId["DataSourceId"] = "data-source-id"; + ParameterId["DataSchema"] = "data-schema"; + ParameterId["DataSourceName"] = "data-source-name"; + ParameterId["ColumnsToInclude"] = "columns-to-include"; + ParameterId["JoinDescription"] = "join-description"; + ParameterId["ConnectionDescriptionSummaries"] = "connection-description-summaries"; + })(ParameterId = exports.ParameterId || (exports.ParameterId = {})); + + +/***/ }, +/* 8 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + // Declare this key type and export the NotificationId to make this behave like a string enum + var VerbId; + (function (VerbId) { + VerbId["ApplyCategoricalFilter"] = "categorical-filter"; + VerbId["ApplyRangeFilter"] = "range-filter"; + VerbId["ClearFilter"] = "clear-filter"; + VerbId["InitializeExtension"] = "initialize-extension"; + VerbId["GetDataSummaryData"] = "get-summary-data"; + VerbId["GetUnderlyingData"] = "get-underlying-data"; + VerbId["GetDataSourceData"] = "get-datasource-data"; + VerbId["SaveExtensionSettings"] = "save-extension-settings"; + VerbId["GetSelectedMarks"] = "get-selected-marks"; + VerbId["GetHighlightedMarks"] = "get-highlighted-marks"; + VerbId["GetParametersForSheet"] = "get-parameters-for-sheet"; + VerbId["FindParameter"] = "find-parameter"; + VerbId["ChangeParameterValue"] = "change-parameter-value"; + VerbId["ClearSelectedMarks"] = "clear-selected-marks"; + VerbId["SelectByValue"] = "select-by-value"; + VerbId["GetDataSources"] = "get-data-sources"; + VerbId["RefreshDataSource"] = "refresh-data-source"; + VerbId["GetFilters"] = "get-filters"; + VerbId["GetCategoricalDomain"] = "get-categorical-domain"; + VerbId["GetRangeDomain"] = "get-range-domain"; + VerbId["GetJoinDescription"] = "get-join-description"; + VerbId["GetConnectionDescriptionSummaries"] = "get-connection-description-summaries"; + })(VerbId = exports.VerbId || (exports.VerbId = {})); + + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + var Dashboard_1 = __webpack_require__(10); + exports.Dashboard = Dashboard_1.Dashboard; + var VersionNumber_1 = __webpack_require__(17); + exports.VersionNumber = VersionNumber_1.VersionNumber; + var DashboardImpl_1 = __webpack_require__(18); + exports.DashboardImpl = DashboardImpl_1.DashboardImpl; + var InternalToExternalEnumMappings_1 = __webpack_require__(23); + exports.InternalToExternalEnumMappings = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings; + __export(__webpack_require__(44)); + __export(__webpack_require__(28)); + __export(__webpack_require__(58)); + + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Sheet_1 = __webpack_require__(11); + var Dashboard = (function (_super) { + __extends(Dashboard, _super); + function Dashboard(_dashboardImpl) { + var _this = _super.call(this, _dashboardImpl) || this; + _this._dashboardImpl = _dashboardImpl; + _dashboardImpl.initializeWithPublicInterfaces(_this); + return _this; + } + Object.defineProperty(Dashboard.prototype, "worksheets", { + get: function () { + return this._dashboardImpl.worksheets; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Dashboard.prototype, "objects", { + get: function () { + return this._dashboardImpl.objects; + }, + enumerable: true, + configurable: true + }); + return Dashboard; + }(Sheet_1.Sheet)); + exports.Dashboard = Dashboard; + + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var EventListenerManager_1 = __webpack_require__(12); + var Sheet = (function (_super) { + __extends(Sheet, _super); + function Sheet(_sheetImpl) { + var _this = _super.call(this) || this; + _this._sheetImpl = _sheetImpl; + return _this; + } + Object.defineProperty(Sheet.prototype, "name", { + get: function () { + return this._sheetImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Sheet.prototype, "sheetType", { + get: function () { + return this._sheetImpl.sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Sheet.prototype, "size", { + get: function () { + return this._sheetImpl.size; + }, + enumerable: true, + configurable: true + }); + Sheet.prototype.findParameterAsync = function (parameterName) { + return this._sheetImpl.findParameterAsync(parameterName, this); + }; + Sheet.prototype.getParametersAsync = function () { + return this._sheetImpl.getParametersAsync(this); + }; + return Sheet; + }(EventListenerManager_1.EventListenerManager)); + exports.Sheet = Sheet; + + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(13); + /** + * Class designed to register and unregister handlers from a user. Only those events + * which are added via AddNewEventType will be supported by this instance + */ + var EventListenerManager = (function () { + function EventListenerManager() { + this._eventListenerManagers = {}; + } + EventListenerManager.prototype.addEventListener = function (eventType, handler) { + if (!this._eventListenerManagers.hasOwnProperty(eventType)) { + throw api_utils_1.TableauException.error(EventListenerManager.UNSUPPORTED_EVENT, [eventType]); + } + return this._eventListenerManagers[eventType].addEventListener(handler); + }; + EventListenerManager.prototype.removeEventListener = function (eventType, handler) { + if (!this._eventListenerManagers.hasOwnProperty(eventType)) { + throw api_utils_1.TableauException.error(EventListenerManager.UNSUPPORTED_EVENT, [eventType]); + } + return this._eventListenerManagers[eventType].removeEventListener(handler); + }; + EventListenerManager.prototype.addNewEventType = function (eventManager) { + this._eventListenerManagers[eventManager.eventType] = eventManager; + }; + EventListenerManager.UNSUPPORTED_EVENT = 'Unsupported event type : %1'; + return EventListenerManager; + }()); + exports.EventListenerManager = EventListenerManager; + + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + var EnumConverter_1 = __webpack_require__(14); + exports.EnumConverter = EnumConverter_1.EnumConverter; + var Param_1 = __webpack_require__(16); + exports.Param = Param_1.Param; + var TableauException_1 = __webpack_require__(15); + exports.TableauException = TableauException_1.TableauException; + + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauException_1 = __webpack_require__(15); + /** + * This class converts from a source enum value to destination enum + * value given a mapping from source to destination when constructed. + */ + var EnumConverter = (function () { + function EnumConverter(_mappings, _defaultVal) { + this._mappings = _mappings; + this._defaultVal = _defaultVal; + } + EnumConverter.prototype.convert = function (enumVal, throwIfMissing) { + if (this._mappings.hasOwnProperty(enumVal)) { + return this._mappings[enumVal]; + } + if (this._defaultVal !== undefined && !throwIfMissing) { + return this._defaultVal; + } + throw TableauException_1.TableauException.error(EnumConverter.MAPPING_NOT_FOUND, [enumVal]); + }; + EnumConverter.MAPPING_NOT_FOUND = 'Mapping not found for %1'; + return EnumConverter; + }()); + exports.EnumConverter = EnumConverter; + + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauException = (function () { + function TableauException() { + } + TableauException.apiNotImplemented = function (params) { + var message = TableauException.format(TableauException.API_NOT_IMPLEMENTED, params); + return new Error(message); + }; + TableauException.isUndefined = function (params) { + var message = TableauException.format(TableauException.UNDEFINED, params); + return new Error(message); + }; + TableauException.isNull = function (params) { + var message = TableauException.format(TableauException.IS_NULL, params); + return new Error(message); + }; + TableauException.invalidParamValue = function (params) { + var message = TableauException.format(TableauException.INVALID_PARAMETER_VALUE, params); + return new Error(message); + }; + TableauException.invalidParamType = function (params) { + var message = TableauException.format(TableauException.INVALID_PARAMETER_TYPE, params); + return new Error(message); + }; + TableauException.missingParameter = function (params) { + var message = TableauException.format(TableauException.MISSING_PARAMETER, params); + return new Error(message); + }; + TableauException.invalid = function (params) { + var message = TableauException.format(TableauException.INVALID, params); + return new Error(message); + }; + TableauException.internalError = function (params) { + var message = TableauException.format(TableauException.INTERNAL_ERROR, params); + return new Error(message); + }; + TableauException.error = function (message, params) { + var result; + if (params) { + result = TableauException.format(message, params); + } + else { + result = message; + } + return new Error(result); + }; + TableauException.format = function (message, params) { + for (var i = 0; i < params.length; i++) { + var match = '%' + (i + 1); + message = message.replace(new RegExp(match, 'g'), params[i]); + } + message = message.replace(new RegExp('%[0-9]+', 'g'), ''); + message = message.trim(); + return message; + }; + TableauException.API_NOT_IMPLEMENTED = '%1 API not yet implemented.'; + TableauException.UNDEFINED = '%1 is undefined.'; + TableauException.INVALID_PARAMETER_VALUE = 'Invalid value for parameter: %1. %2'; + TableauException.INVALID_PARAMETER_TYPE = 'Invalid type for parameter: %1. %2'; + TableauException.MISSING_PARAMETER = 'Missing Parameter: %1.'; + TableauException.UNKNOWN_ERROR = 'Unknown error.'; + TableauException.INTERNAL_ERROR = 'Internal error: %1.'; + TableauException.INVALID = 'Invalid: %1. %2'; + TableauException.IS_NULL = '%1 is null.'; + return TableauException; + }()); + exports.TableauException = TableauException; + + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauException_1 = __webpack_require__(15); + var Param = (function () { + function Param() { + } + /** + * Verifies that an incoming parameter is 'truthy' and throws + * an error if it's not. This will throw an error if the value + * is null, undefined, NaN, the empty string, 0, or false. + * + * @param argumentValue value to verify + * @param argumentName name of argument to verify + */ + /*tslint:disable-next-line */ + Param.verifyValue = function (argumentValue, argumentName) { + if (!argumentValue) { + throw TableauException_1.TableauException.invalidParamValue([argumentName]); + } + }; + /** + * Verifies that a string is valid. Throws an error if the string is + * null, undefined, or NaN. + * + * @param argumentValue value to verify + * @param argumentName name of argument to verify + */ + Param.verifyString = function (argumentValue, argumentName) { + if (argumentValue === null || argumentValue === undefined) { + throw TableauException_1.TableauException.invalidParamValue([argumentName]); + } + }; + /** + * Verifies the value is part of the Enum + * + * String enums are {string : string} dictionaries which are not reverse mappable + * This is an ugly workaround + * @param value value to verify + * @param enumType enum to verify against + */ + /* tslint:disable:no-any */ + Param.isValidEnumValue = function (value, enumType) { + var isValid = false; + Object.keys(enumType).forEach(function (enumKey) { + if (enumType[enumKey] === value.toString()) { + isValid = true; + } + }); + return isValid; + }; + /* tslint:enable:no-any */ + /** + * serializes the date into the format that the server expects. + * @param date the date to serialize + */ + Param.serializeDateForPlatform = function (date) { + var year = date.getUTCFullYear(); + var month = date.getUTCMonth() + 1; + var day = date.getUTCDate(); + var hh = date.getUTCHours(); + var mm = date.getUTCMinutes(); + var sec = date.getUTCSeconds(); + return year + '-' + month + '-' + day + ' ' + hh + ':' + mm + ':' + sec; + }; + Param.serializeBooleanForPlatform = function (bool) { + return bool ? 'true' : 'false'; + }; + Param.serializeNumberForPlatform = function (num) { + return num.toString(10); + }; + /** + * Verifies the params min and max for applying range filter + * @param min range min + * @param max range max + */ + /* tslint:disable:no-any */ + Param.verifyRangeParamType = function (min, max) { + /* tslint:enable:no-any */ + if (!min && !max) { + throw TableauException_1.TableauException.invalidParamValue(['Range parameters', 'At least one of min or max is required.']); + } + if (!Param.isTypeNumber(min) && !Param.isTypeDate(min)) { + throw TableauException_1.TableauException.invalidParamType(['Range parameters', 'Only Date and number are allowed for parameter min.']); + } + if (!Param.isTypeNumber(max) && !Param.isTypeDate(max)) { + throw TableauException_1.TableauException.invalidParamType(['Range parameters', 'Only Date and number are allowed for parameter max.']); + } + if (typeof (min) !== typeof (max)) { + throw TableauException_1.TableauException.invalidParamType(['Range parameters', 'Parameters min and max should be of the same type.']); + } + }; + /** + * Verifies the input is a number + */ + /* tslint:disable:no-any */ + Param.isTypeNumber = function (input) { + return typeof (input) === 'number' || input instanceof Number; + }; + /* tslint:enable:no-any */ + /** + * Verifies the input is a Date + */ + /* tslint:disable:no-any */ + Param.isTypeDate = function (input) { + return input instanceof Date; + }; + /* tslint:enable:no-any */ + /* tslint:disable-next-line:no-any */ + Param.isTypeString = function (input) { + return typeof (input) === 'string' || input instanceof String; + }; + /* tslint:disable-next-line:no-any */ + Param.isTypeBool = function (input) { + return typeof (input) === 'boolean' || input instanceof Boolean; + }; + /* tslint:disable-next-line:no-any */ + Param.serializeParamterValue = function (value) { + if (Param.isTypeNumber(value)) { + return Param.serializeNumberForPlatform(value); + } + else if (Param.isTypeDate(value)) { + return Param.serializeDateForPlatform(value); + } + else if (Param.isTypeBool(value)) { + return Param.serializeBooleanForPlatform(value); + } + else if (Param.isTypeString(value)) { + return value; + } + else { + throw TableauException_1.TableauException.invalidParamValue(['value']); + } + }; + return Param; + }()); + exports.Param = Param; + + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(13); + /** + * Represents the current version of the extensions library + */ + var VersionNumber = (function () { + // private constructor so everyone uses the singleton instance + function VersionNumber(versionString) { + var parts = versionString.split('.').map(function (p) { return parseInt(p, 10); }); + if (parts.length !== 3) { + throw api_utils_1.TableauException.error(VersionNumber.INVALID_VERSION_NUMBER, [versionString]); + } + this.major = parts[0]; + this.minor = parts[1]; + this.fix = parts[2]; + } + Object.defineProperty(VersionNumber, "Instance", { + /** + * Gets the singleton instance of the version number. + */ + get: function () { + return VersionNumber._instance; + }, + enumerable: true, + configurable: true + }); + VersionNumber.SetVersionNumber = function (numString) { + VersionNumber._instance = new VersionNumber(numString); + }; + Object.defineProperty(VersionNumber.prototype, "formattedValue", { + get: function () { + return this.major + "." + this.minor + "." + this.fix; + }, + enumerable: true, + configurable: true + }); + VersionNumber.INVALID_VERSION_NUMBER = 'Invalid version number: '; + return VersionNumber; + }()); + exports.VersionNumber = VersionNumber; + + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var DashboardObject_1 = __webpack_require__(22); + var InternalToExternalEnumMappings_1 = __webpack_require__(23); + var Point_1 = __webpack_require__(24); + var Size_1 = __webpack_require__(25); + var Worksheet_1 = __webpack_require__(26); + var SheetImpl_1 = __webpack_require__(27); + var SheetInfoImpl_1 = __webpack_require__(29); + var WorksheetImpl_1 = __webpack_require__(30); + var DashboardImpl = (function (_super) { + __extends(DashboardImpl, _super); + function DashboardImpl(_info, _sheetPath) { + var _this = _super.call(this, new SheetInfoImpl_1.SheetInfoImpl(_info.name, Contract.SheetType.Dashboard, new Size_1.Size(_info.size.h, _info.size.w))) || this; + _this._info = _info; + _this._sheetPath = _sheetPath; + return _this; + } + Object.defineProperty(DashboardImpl.prototype, "worksheets", { + get: function () { + return this._worksheets; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardImpl.prototype, "objects", { + get: function () { + return this._objects; + }, + enumerable: true, + configurable: true + }); + DashboardImpl.prototype.initializeWithPublicInterfaces = function (dashboard) { + this._worksheets = new Array(); + this._objects = new Array(); + // Process all the zones which are contained in this dashboard + for (var _i = 0, _a = this._info.zones; _i < _a.length; _i++) { + var zone = _a[_i]; + var worksheet = undefined; + var zoneSize = new Size_1.Size(zone.height, zone.width); + if (zone.zoneType === api_internal_contract_1.DashboardObjectType.Worksheet) { + var sheetInfo = new SheetInfoImpl_1.SheetInfoImpl(zone.name, Contract.SheetType.Worksheet, zoneSize); + var vizId = { + worksheet: zone.name, + dashboard: this._info.name, + storyboard: this._sheetPath.storyboard, + flipboardZoneID: this._sheetPath.flipboardZoneID, + storyPointID: this._sheetPath.storyPointID + }; + var worksheetImpl = new WorksheetImpl_1.WorksheetImpl(sheetInfo, vizId, dashboard); + worksheet = new Worksheet_1.Worksheet(worksheetImpl); + this._worksheets.push(worksheet); + } + var zonePoint = new Point_1.Point(zone.x, zone.y); + var dashboardObject = new DashboardObject_1.DashboardObject(dashboard, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType), zonePoint, zoneSize, worksheet); + this._objects.push(dashboardObject); + } + }; + return DashboardImpl; + }(SheetImpl_1.SheetImpl)); + exports.DashboardImpl = DashboardImpl; + + +/***/ }, +/* 19 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(20)); + + +/***/ }, +/* 20 */ +/***/ function(module, exports) { + + "use strict"; + // All enum values made available to Extensions developers. + // Enums should be kept in alphabetical order. + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * The context in which the Extensions is currently running. + */ + var ExtensionContext; + (function (ExtensionContext) { + ExtensionContext["Desktop"] = "desktop"; + ExtensionContext["Server"] = "server"; + })(ExtensionContext = exports.ExtensionContext || (exports.ExtensionContext = {})); + /** + * The mode in which the Extensions is currently running. + */ + var ExtensionMode; + (function (ExtensionMode) { + ExtensionMode["Authoring"] = "authoring"; + ExtensionMode["Viewing"] = "viewing"; + })(ExtensionMode = exports.ExtensionMode || (exports.ExtensionMode = {})); + var AnalyticsObjectType; + (function (AnalyticsObjectType) { + AnalyticsObjectType["Cluster"] = "cluster"; + AnalyticsObjectType["Forecast"] = "forecast"; + AnalyticsObjectType["TrendLine"] = "trend-line"; + })(AnalyticsObjectType = exports.AnalyticsObjectType || (exports.AnalyticsObjectType = {})); + var ColumnType; + (function (ColumnType) { + ColumnType["Discrete"] = "discrete"; + ColumnType["Continuous"] = "continuous"; + })(ColumnType = exports.ColumnType || (exports.ColumnType = {})); + /** + * What the object represents in a dashboard. + */ + var DashboardObjectType; + (function (DashboardObjectType) { + DashboardObjectType["Blank"] = "blank"; + DashboardObjectType["Worksheet"] = "worksheet"; + DashboardObjectType["QuickFilter"] = "quick-filter"; + DashboardObjectType["ParameterControl"] = "parameter-control"; + DashboardObjectType["PageFilter"] = "page-filter"; + DashboardObjectType["Legend"] = "legend"; + DashboardObjectType["Title"] = "title"; + DashboardObjectType["Text"] = "text"; + DashboardObjectType["Image"] = "image"; + DashboardObjectType["WebPage"] = "web-page"; + DashboardObjectType["Extension"] = "extension"; + })(DashboardObjectType = exports.DashboardObjectType || (exports.DashboardObjectType = {})); + /** + * The different types of data a value can have + */ + var DataType; + (function (DataType) { + DataType["String"] = "string"; + DataType["Int"] = "int"; + DataType["Float"] = "float"; + DataType["Bool"] = "bool"; + DataType["Date"] = "date"; + DataType["DateTime"] = "date-time"; + DataType["Spatial"] = "spatial"; + })(DataType = exports.DataType || (exports.DataType = {})); + /** + * Valid date ranges for a relative date filter. + */ + var DateRangeType; + (function (DateRangeType) { + DateRangeType["Last"] = "last"; + DateRangeType["LastN"] = "last-n"; + DateRangeType["Next"] = "next"; + DateRangeType["NextN"] = "next-n"; + DateRangeType["Current"] = "current"; + DateRangeType["ToDate"] = "to-date"; + })(DateRangeType = exports.DateRangeType || (exports.DateRangeType = {})); + /** + * Types of dialog event for event listening between a parent Extensions and a popup dialog. + */ + var DialogEventType; + (function (DialogEventType) { + DialogEventType["DialogMessage"] = "dialog-message"; + DialogEventType["DialogEvent"] = "dialog-event"; + })(DialogEventType = exports.DialogEventType || (exports.DialogEventType = {})); + var EncodingType; + (function (EncodingType) { + EncodingType["Column"] = "column"; + EncodingType["Row"] = "row"; + EncodingType["Page"] = "page"; + EncodingType["Filter"] = "filter"; + EncodingType["MarksType"] = "marks-type"; + EncodingType["MeasureValues"] = "measure-values"; + EncodingType["Color"] = "color"; + EncodingType["Size"] = "size"; + EncodingType["Label"] = "label"; + EncodingType["Detail"] = "detail"; + EncodingType["Tooltip"] = "tooltip"; + EncodingType["Shape"] = "shape"; + EncodingType["Path"] = "path"; + EncodingType["Angle"] = "angle"; + })(EncodingType = exports.EncodingType || (exports.EncodingType = {})); + /** + * All error codes used by the Extensions API. + */ + var ErrorCodes; + (function (ErrorCodes) { + /** + * Only one dialog can be opened at time with the UI namespace functionality. + */ + ErrorCodes["DialogAlreadyOpen"] = "dialog-already-open"; + /** + * The open dialog was closed by the user. + */ + ErrorCodes["DialogClosedByUser"] = "dialog-closed-by-user"; + /** + * An error occurred while attempting to perform a filter operation. + */ + ErrorCodes["FilterCannotBePerformed"] = "filter-cannot-be-performed"; + /** + * An error occurred within the Tableau Extensions API. Contact Tableau Support. + */ + ErrorCodes["InternalError"] = "internal-error"; + /** + * An invalid aggregation was specified for the filter, such as setting a range filter to "SUM(Sales)" instead of "Sales". + */ + ErrorCodes["InvalidAggregationFieldName"] = "invalid-aggregation-field-name"; + /** + * A dialog must first launch to, and send messages from, the same domain as the parent Extensions. + */ + ErrorCodes["InvalidDomainDialog"] = "invalid-dialog-domain"; + /** + * An invalid date was specified in a method that required a date parameter. + */ + ErrorCodes["InvalidDateParameter"] = "invalid-date-parameter"; + /** + * A filter operation was attempted on a field that does not exist in the data source. + */ + ErrorCodes["InvalidFilterFieldName"] = "invalid-filter-field-name"; + /** + * A filter operation was attempted using a value that is the wrong data type or format. + */ + ErrorCodes["InvalidFilterFieldValue"] = "invalid-filter-field-value"; + /** + * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field. + */ + ErrorCodes["InvalidParameter"] = "invalid-parameter"; + /** + * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field. + */ + ErrorCodes["InvalidSelectionDate"] = "invalid-selection-date"; + /** + * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source. + */ + ErrorCodes["InvalidSelectionFieldName"] = "invalid-selection-field-name"; + /** + * An invalid value was specified in a Sheet.selectMarksAsync() call. + */ + ErrorCodes["InvalidSelectionValue"] = "invalid-selection-value"; + /** + * A required parameter was not specified, null, or an empty string/array. + */ + ErrorCodes["NullOrEmptyParameter"] = "null-or-empty-parameter"; + /** + * An unknown event name was specified in the call to Viz.addEventListeneror Viz.removeEventListener. + */ + ErrorCodes["UnsupportedEventName"] = "unsupported-event-name"; + /** + * A method was used for a type of datasource that doesn't support that method (see getActiveTablesAsync for an example) + */ + ErrorCodes["UnsupportedMethodForDataSourceType"] = "unsupported-method-for-data-source-type"; + })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {})); + /** + * Type of aggregation on a field. + */ + var FieldAggregationType; + (function (FieldAggregationType) { + FieldAggregationType["Sum"] = "sum"; + FieldAggregationType["Avg"] = "avg"; + FieldAggregationType["Min"] = "min"; + FieldAggregationType["Max"] = "max"; + FieldAggregationType["Stdev"] = "stdev"; + FieldAggregationType["Stdevp"] = "stdevp"; + FieldAggregationType["Var"] = "var"; + FieldAggregationType["Varp"] = "varp"; + FieldAggregationType["Count"] = "count"; + FieldAggregationType["Countd"] = "countd"; + FieldAggregationType["Median"] = "median"; + FieldAggregationType["Attr"] = "attr"; + FieldAggregationType["None"] = "none"; + FieldAggregationType["Year"] = "year"; + FieldAggregationType["Qtr"] = "qtr"; + FieldAggregationType["Month"] = "month"; + FieldAggregationType["Day"] = "day"; + FieldAggregationType["Hour"] = "hour"; + FieldAggregationType["Minute"] = "minute"; + FieldAggregationType["Second"] = "second"; + FieldAggregationType["Week"] = "week"; + FieldAggregationType["Weekday"] = "weekday"; + FieldAggregationType["MonthYear"] = "month-year"; + FieldAggregationType["Mdy"] = "mdy"; + FieldAggregationType["End"] = "end"; + FieldAggregationType["TruncYear"] = "trunc-year"; + FieldAggregationType["TruncQtr"] = "trunc-qtr"; + FieldAggregationType["TruncMonth"] = "trunc-month"; + FieldAggregationType["TruncWeek"] = "trunc-week"; + FieldAggregationType["TruncDay"] = "trunc-day"; + FieldAggregationType["TruncHour"] = "trunc-hour"; + FieldAggregationType["TruncMinute"] = "trunc-minute"; + FieldAggregationType["TruncSecond"] = "trunc-second"; + FieldAggregationType["Quart1"] = "quart1"; + FieldAggregationType["Quart3"] = "quart3"; + FieldAggregationType["Skewness"] = "skewness"; + FieldAggregationType["Kurtosis"] = "kurtosis"; + FieldAggregationType["InOut"] = "in-out"; + FieldAggregationType["User"] = "user"; + })(FieldAggregationType = exports.FieldAggregationType || (exports.FieldAggregationType = {})); + /** + * Role of a field. + */ + var FieldRoleType; + (function (FieldRoleType) { + FieldRoleType["Dimension"] = "dimension"; + FieldRoleType["Measure"] = "measure"; + FieldRoleType["Unknown"] = "unknown"; + })(FieldRoleType = exports.FieldRoleType || (exports.FieldRoleType = {})); + /** + * An enumeration of the valid types of filters that can be applied. + */ + var FilterType; + (function (FilterType) { + FilterType["Categorical"] = "categorical"; + FilterType["Range"] = "range"; + FilterType["Hierarchical"] = "hierarchical"; + FilterType["RelativeDate"] = "relative-date"; + })(FilterType = exports.FilterType || (exports.FilterType = {})); + /** + * The different update types for applying filter + */ + var FilterUpdateType; + (function (FilterUpdateType) { + FilterUpdateType["Add"] = "add"; + FilterUpdateType["All"] = "all"; + FilterUpdateType["Replace"] = "replace"; + FilterUpdateType["Remove"] = "remove"; + })(FilterUpdateType = exports.FilterUpdateType || (exports.FilterUpdateType = {})); + /** + * The domain type for a filter + */ + var FilterDomainType; + (function (FilterDomainType) { + /** + * The domain values that are relevant to the specified filter + * i.e. the domain is restricted by a previous filter + */ + FilterDomainType["Relevant"] = "relevant"; + /** + * list of all possible domain values from database + */ + FilterDomainType["Database"] = "database"; + })(FilterDomainType = exports.FilterDomainType || (exports.FilterDomainType = {})); + /** + * The option for specifying which values to include for filtering + * Indicates what to do with null values for a given filter or mark selection call. + */ + var FilterNullOption; + (function (FilterNullOption) { + FilterNullOption["NullValues"] = "null-values"; + FilterNullOption["NonNullValues"] = "non-null-values"; + FilterNullOption["AllValues"] = "all-values"; + })(FilterNullOption = exports.FilterNullOption || (exports.FilterNullOption = {})); + /** + * Type of mark for a given marks card in a viz. + */ + var MarkType; + (function (MarkType) { + MarkType["Bar"] = "bar"; + MarkType["Line"] = "line"; + MarkType["Area"] = "area"; + MarkType["Square"] = "square"; + MarkType["Circle"] = "circle"; + MarkType["Shape"] = "shape"; + MarkType["Text"] = "text"; + MarkType["Map"] = "map"; + MarkType["Pie"] = "pie"; + MarkType["GanttBar"] = "gantt-bar"; + MarkType["Polygon"] = "polygon"; + })(MarkType = exports.MarkType || (exports.MarkType = {})); + /** + * An enumeration describing the different types of allowable values. + * This is used for restricting the domain of a parameter + */ + var ParameterValueType; + (function (ParameterValueType) { + ParameterValueType["All"] = "all"; + ParameterValueType["List"] = "list"; + ParameterValueType["Range"] = "range"; + })(ParameterValueType = exports.ParameterValueType || (exports.ParameterValueType = {})); + /** + * Date period used in filters and in parameters. + */ + var PeriodType; + (function (PeriodType) { + PeriodType["Years"] = "years"; + PeriodType["Quarters"] = "quarters"; + PeriodType["Months"] = "months"; + PeriodType["Weeks"] = "weeks"; + PeriodType["Days"] = "days"; + PeriodType["Hours"] = "hours"; + PeriodType["Minutes"] = "minutes"; + PeriodType["Seconds"] = "seconds"; + })(PeriodType = exports.PeriodType || (exports.PeriodType = {})); + var QuickTableCalcType; + (function (QuickTableCalcType) { + QuickTableCalcType["RunningTotal"] = "running-total"; + QuickTableCalcType["Difference"] = "difference"; + QuickTableCalcType["PercentDifference"] = "percent-difference"; + QuickTableCalcType["PercentOfTotal"] = "percent-of-total"; + QuickTableCalcType["Rank"] = "rank"; + QuickTableCalcType["Percentile"] = "percentile"; + QuickTableCalcType["MovingAverage"] = "moving-average"; + QuickTableCalcType["YTDTotal"] = "ytd-total"; + QuickTableCalcType["CompoundGrowthRate"] = "compound-growth-rate"; + QuickTableCalcType["YearOverYearGrowth"] = "year-over-year-growth"; + QuickTableCalcType["YTDGrowth"] = "ytd-growth"; + QuickTableCalcType["Undefined"] = "undefined"; + })(QuickTableCalcType = exports.QuickTableCalcType || (exports.QuickTableCalcType = {})); + /** + * Enum for specifying the selection type for select marks api. + */ + var SelectionUpdateType; + (function (SelectionUpdateType) { + SelectionUpdateType["Replace"] = "select-replace"; + SelectionUpdateType["Add"] = "select-add"; + SelectionUpdateType["Remove"] = "select-remove"; + })(SelectionUpdateType = exports.SelectionUpdateType || (exports.SelectionUpdateType = {})); + /** + * The type of sheet a Sheet object represents + */ + var SheetType; + (function (SheetType) { + SheetType["Dashboard"] = "dashboard"; + SheetType["Story"] = "story"; + SheetType["Worksheet"] = "worksheet"; + })(SheetType = exports.SheetType || (exports.SheetType = {})); + var SortDirection; + (function (SortDirection) { + SortDirection["Increasing"] = "increasing"; + SortDirection["Decreasing"] = "decreasing"; + })(SortDirection = exports.SortDirection || (exports.SortDirection = {})); + /** + * Represents a certain type of event which can be listened for + */ + var TableauEventType; + (function (TableauEventType) { + /** Raised when any filter has changed state.*/ + TableauEventType["FilterChanged"] = "filter-changed"; + /** The selected marks on a visualization has changed */ + TableauEventType["MarkSelectionChanged"] = "mark-selection-changed"; + /** A parameter has had its value modified */ + TableauEventType["ParameterChanged"] = "parameter-changed"; + })(TableauEventType = exports.TableauEventType || (exports.TableauEventType = {})); + var TrendLineModelType; + (function (TrendLineModelType) { + TrendLineModelType["Linear"] = "linear"; + TrendLineModelType["Logarithmic"] = "logarithmic"; + TrendLineModelType["Exponential"] = "exponential"; + TrendLineModelType["Polynomial"] = "polynomial"; + })(TrendLineModelType = exports.TrendLineModelType || (exports.TrendLineModelType = {})); + + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(4)); + __export(__webpack_require__(5)); + __export(__webpack_require__(6)); + __export(__webpack_require__(7)); + __export(__webpack_require__(8)); + + +/***/ }, +/* 22 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the dashboard objects - the zones in a dashboard. + * This does not follow the Impl pattern as it is just a property bag. + */ + var DashboardObject = (function () { + function DashboardObject(_dashboard, _type, _position, _size, _worksheet) { + this._dashboard = _dashboard; + this._type = _type; + this._position = _position; + this._size = _size; + this._worksheet = _worksheet; + } + Object.defineProperty(DashboardObject.prototype, "dashboard", { + get: function () { + return this._dashboard; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "position", { + get: function () { + return this._position; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "size", { + get: function () { + return this._size; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "worksheet", { + get: function () { + return this._worksheet; + }, + enumerable: true, + configurable: true + }); + return DashboardObject; + }()); + exports.DashboardObject = DashboardObject; + + +/***/ }, +/* 23 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_external_contract_1 = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + /* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */ + /** + * Maps enums used by the internal-api-contract to the enums used + * in the external-api-contract, which developers code against. + */ + var InternalToExternalEnumMappings = (function () { + function InternalToExternalEnumMappings() { + } + InternalToExternalEnumMappings.extensionContext = new api_utils_1.EnumConverter((_a = {}, + _a[api_internal_contract_1.ExtensionContext.Desktop] = api_external_contract_1.ExtensionContext.Desktop, + _a[api_internal_contract_1.ExtensionContext.Server] = api_external_contract_1.ExtensionContext.Server, + _a)); + InternalToExternalEnumMappings.extensionMode = new api_utils_1.EnumConverter((_b = {}, + _b[api_internal_contract_1.ExtensionMode.Authoring] = api_external_contract_1.ExtensionMode.Authoring, + _b[api_internal_contract_1.ExtensionMode.Viewing] = api_external_contract_1.ExtensionMode.Viewing, + _b)); + InternalToExternalEnumMappings.columnType = new api_utils_1.EnumConverter((_c = {}, + _c[api_internal_contract_1.ColumnType.Continuous] = api_external_contract_1.ColumnType.Continuous, + _c[api_internal_contract_1.ColumnType.Discrete] = api_external_contract_1.ColumnType.Discrete, + _c)); + InternalToExternalEnumMappings.fieldAggregationType = new api_utils_1.EnumConverter((_d = {}, + _d[api_internal_contract_1.FieldAggregationType.Attr] = api_external_contract_1.FieldAggregationType.Attr, + _d[api_internal_contract_1.FieldAggregationType.Avg] = api_external_contract_1.FieldAggregationType.Avg, + _d[api_internal_contract_1.FieldAggregationType.Count] = api_external_contract_1.FieldAggregationType.Count, + _d[api_internal_contract_1.FieldAggregationType.Countd] = api_external_contract_1.FieldAggregationType.Countd, + _d[api_internal_contract_1.FieldAggregationType.Day] = api_external_contract_1.FieldAggregationType.Day, + _d[api_internal_contract_1.FieldAggregationType.End] = api_external_contract_1.FieldAggregationType.End, + _d[api_internal_contract_1.FieldAggregationType.Hour] = api_external_contract_1.FieldAggregationType.Hour, + _d[api_internal_contract_1.FieldAggregationType.InOut] = api_external_contract_1.FieldAggregationType.InOut, + _d[api_internal_contract_1.FieldAggregationType.Kurtosis] = api_external_contract_1.FieldAggregationType.Kurtosis, + _d[api_internal_contract_1.FieldAggregationType.Max] = api_external_contract_1.FieldAggregationType.Max, + _d[api_internal_contract_1.FieldAggregationType.Mdy] = api_external_contract_1.FieldAggregationType.Mdy, + _d[api_internal_contract_1.FieldAggregationType.Median] = api_external_contract_1.FieldAggregationType.Median, + _d[api_internal_contract_1.FieldAggregationType.Min] = api_external_contract_1.FieldAggregationType.Min, + _d[api_internal_contract_1.FieldAggregationType.Minute] = api_external_contract_1.FieldAggregationType.Minute, + _d[api_internal_contract_1.FieldAggregationType.MonthYear] = api_external_contract_1.FieldAggregationType.MonthYear, + _d[api_internal_contract_1.FieldAggregationType.None] = api_external_contract_1.FieldAggregationType.None, + _d[api_internal_contract_1.FieldAggregationType.Qtr] = api_external_contract_1.FieldAggregationType.Qtr, + _d[api_internal_contract_1.FieldAggregationType.Quart1] = api_external_contract_1.FieldAggregationType.Quart1, + _d[api_internal_contract_1.FieldAggregationType.Quart3] = api_external_contract_1.FieldAggregationType.Quart3, + _d[api_internal_contract_1.FieldAggregationType.Second] = api_external_contract_1.FieldAggregationType.Second, + _d[api_internal_contract_1.FieldAggregationType.Skewness] = api_external_contract_1.FieldAggregationType.Skewness, + _d[api_internal_contract_1.FieldAggregationType.Stdev] = api_external_contract_1.FieldAggregationType.Stdev, + _d[api_internal_contract_1.FieldAggregationType.Stdevp] = api_external_contract_1.FieldAggregationType.Stdevp, + _d[api_internal_contract_1.FieldAggregationType.Sum] = api_external_contract_1.FieldAggregationType.Sum, + _d[api_internal_contract_1.FieldAggregationType.TruncDay] = api_external_contract_1.FieldAggregationType.TruncDay, + _d[api_internal_contract_1.FieldAggregationType.TruncHour] = api_external_contract_1.FieldAggregationType.TruncHour, + _d[api_internal_contract_1.FieldAggregationType.TruncMinute] = api_external_contract_1.FieldAggregationType.TruncMinute, + _d[api_internal_contract_1.FieldAggregationType.TruncMonth] = api_external_contract_1.FieldAggregationType.TruncMonth, + _d[api_internal_contract_1.FieldAggregationType.TruncQtr] = api_external_contract_1.FieldAggregationType.TruncQtr, + _d[api_internal_contract_1.FieldAggregationType.TruncSecond] = api_external_contract_1.FieldAggregationType.TruncSecond, + _d[api_internal_contract_1.FieldAggregationType.TruncWeek] = api_external_contract_1.FieldAggregationType.TruncWeek, + _d[api_internal_contract_1.FieldAggregationType.TruncYear] = api_external_contract_1.FieldAggregationType.TruncYear, + _d[api_internal_contract_1.FieldAggregationType.User] = api_external_contract_1.FieldAggregationType.User, + _d[api_internal_contract_1.FieldAggregationType.Var] = api_external_contract_1.FieldAggregationType.Var, + _d[api_internal_contract_1.FieldAggregationType.Varp] = api_external_contract_1.FieldAggregationType.Varp, + _d[api_internal_contract_1.FieldAggregationType.Week] = api_external_contract_1.FieldAggregationType.Week, + _d[api_internal_contract_1.FieldAggregationType.Weekday] = api_external_contract_1.FieldAggregationType.Weekday, + _d[api_internal_contract_1.FieldAggregationType.Year] = api_external_contract_1.FieldAggregationType.Year, + _d)); + InternalToExternalEnumMappings.fieldRoleType = new api_utils_1.EnumConverter((_e = {}, + _e[api_internal_contract_1.FieldRoleType.Dimension] = api_external_contract_1.FieldRoleType.Dimension, + _e[api_internal_contract_1.FieldRoleType.Measure] = api_external_contract_1.FieldRoleType.Measure, + _e[api_internal_contract_1.FieldRoleType.Unknown] = api_external_contract_1.FieldRoleType.Unknown, + _e)); + InternalToExternalEnumMappings.sheetType = new api_utils_1.EnumConverter((_f = {}, + _f[api_internal_contract_1.SheetType.Dashboard] = api_external_contract_1.SheetType.Dashboard, + _f[api_internal_contract_1.SheetType.Story] = api_external_contract_1.SheetType.Story, + _f[api_internal_contract_1.SheetType.Worksheet] = api_external_contract_1.SheetType.Worksheet, + _f)); + InternalToExternalEnumMappings.dashboardObjectType = new api_utils_1.EnumConverter((_g = {}, + _g[api_internal_contract_1.DashboardObjectType.Extension] = api_external_contract_1.DashboardObjectType.Extension, + _g[api_internal_contract_1.DashboardObjectType.Blank] = api_external_contract_1.DashboardObjectType.Blank, + _g[api_internal_contract_1.DashboardObjectType.Image] = api_external_contract_1.DashboardObjectType.Image, + _g[api_internal_contract_1.DashboardObjectType.Legend] = api_external_contract_1.DashboardObjectType.Legend, + _g[api_internal_contract_1.DashboardObjectType.PageFilter] = api_external_contract_1.DashboardObjectType.PageFilter, + _g[api_internal_contract_1.DashboardObjectType.ParameterControl] = api_external_contract_1.DashboardObjectType.ParameterControl, + _g[api_internal_contract_1.DashboardObjectType.QuickFilter] = api_external_contract_1.DashboardObjectType.QuickFilter, + _g[api_internal_contract_1.DashboardObjectType.Text] = api_external_contract_1.DashboardObjectType.Text, + _g[api_internal_contract_1.DashboardObjectType.Title] = api_external_contract_1.DashboardObjectType.Title, + _g[api_internal_contract_1.DashboardObjectType.WebPage] = api_external_contract_1.DashboardObjectType.WebPage, + _g[api_internal_contract_1.DashboardObjectType.Worksheet] = api_external_contract_1.DashboardObjectType.Worksheet, + _g)); + InternalToExternalEnumMappings.dataType = new api_utils_1.EnumConverter((_h = {}, + _h[api_internal_contract_1.DataType.Bool] = api_external_contract_1.DataType.Bool, + _h[api_internal_contract_1.DataType.Date] = api_external_contract_1.DataType.Date, + _h[api_internal_contract_1.DataType.DateTime] = api_external_contract_1.DataType.DateTime, + _h[api_internal_contract_1.DataType.Float] = api_external_contract_1.DataType.Float, + _h[api_internal_contract_1.DataType.Int] = api_external_contract_1.DataType.Int, + _h[api_internal_contract_1.DataType.String] = api_external_contract_1.DataType.String, + _h)); + InternalToExternalEnumMappings.filterUpdateType = new api_utils_1.EnumConverter((_j = {}, + _j[api_internal_contract_1.FilterUpdateType.Add] = api_external_contract_1.FilterUpdateType.Add, + _j[api_internal_contract_1.FilterUpdateType.All] = api_external_contract_1.FilterUpdateType.All, + _j[api_internal_contract_1.FilterUpdateType.Remove] = api_external_contract_1.FilterUpdateType.Remove, + _j[api_internal_contract_1.FilterUpdateType.Replace] = api_external_contract_1.FilterUpdateType.Replace, + _j)); + InternalToExternalEnumMappings.allowableValues = new api_utils_1.EnumConverter((_k = {}, + _k[api_internal_contract_1.DomainRestrictionType.All] = api_external_contract_1.ParameterValueType.All, + _k[api_internal_contract_1.DomainRestrictionType.List] = api_external_contract_1.ParameterValueType.List, + _k[api_internal_contract_1.DomainRestrictionType.Range] = api_external_contract_1.ParameterValueType.Range, + _k)); + InternalToExternalEnumMappings.dateStepPeriod = new api_utils_1.EnumConverter((_l = {}, + _l[api_internal_contract_1.DateStepPeriod.Years] = api_external_contract_1.PeriodType.Years, + _l[api_internal_contract_1.DateStepPeriod.Quarters] = api_external_contract_1.PeriodType.Quarters, + _l[api_internal_contract_1.DateStepPeriod.Months] = api_external_contract_1.PeriodType.Months, + _l[api_internal_contract_1.DateStepPeriod.Weeks] = api_external_contract_1.PeriodType.Weeks, + _l[api_internal_contract_1.DateStepPeriod.Days] = api_external_contract_1.PeriodType.Days, + _l[api_internal_contract_1.DateStepPeriod.Hours] = api_external_contract_1.PeriodType.Hours, + _l[api_internal_contract_1.DateStepPeriod.Minutes] = api_external_contract_1.PeriodType.Minutes, + _l[api_internal_contract_1.DateStepPeriod.Seconds] = api_external_contract_1.PeriodType.Seconds, + _l)); + InternalToExternalEnumMappings.dateRangeType = new api_utils_1.EnumConverter((_m = {}, + _m[api_internal_contract_1.DateRangeType.Current] = api_external_contract_1.DateRangeType.Current, + _m[api_internal_contract_1.DateRangeType.Last] = api_external_contract_1.DateRangeType.Last, + _m[api_internal_contract_1.DateRangeType.LastN] = api_external_contract_1.DateRangeType.LastN, + _m[api_internal_contract_1.DateRangeType.Next] = api_external_contract_1.DateRangeType.Next, + _m[api_internal_contract_1.DateRangeType.NextN] = api_external_contract_1.DateRangeType.NextN, + _m[api_internal_contract_1.DateRangeType.ToDate] = api_external_contract_1.DateRangeType.ToDate, + _m)); + InternalToExternalEnumMappings.filterType = new api_utils_1.EnumConverter((_o = {}, + _o[api_internal_contract_1.FilterType.Categorical] = api_external_contract_1.FilterType.Categorical, + _o[api_internal_contract_1.FilterType.Range] = api_external_contract_1.FilterType.Range, + _o[api_internal_contract_1.FilterType.RelativeDate] = api_external_contract_1.FilterType.RelativeDate, + _o[api_internal_contract_1.FilterType.Hierarchical] = api_external_contract_1.FilterType.Hierarchical, + _o)); + return InternalToExternalEnumMappings; + }()); + exports.InternalToExternalEnumMappings = InternalToExternalEnumMappings; + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o; + /* tslint:enable:typedef */ + + +/***/ }, +/* 24 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Point = (function () { + function Point(_x, _y) { + this._x = _x; + this._y = _y; + } + Object.defineProperty(Point.prototype, "x", { + get: function () { + return this._x; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Point.prototype, "y", { + get: function () { + return this._y; + }, + enumerable: true, + configurable: true + }); + return Point; + }()); + exports.Point = Point; + + +/***/ }, +/* 25 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Size = (function () { + function Size(_height, _width) { + this._height = _height; + this._width = _width; + } + Object.defineProperty(Size.prototype, "height", { + get: function () { + return this._height; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Size.prototype, "width", { + get: function () { + return this._width; + }, + enumerable: true, + configurable: true + }); + return Size; + }()); + exports.Size = Size; + + +/***/ }, +/* 26 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(13); + var Sheet_1 = __webpack_require__(11); + var Worksheet = (function (_super) { + __extends(Worksheet, _super); + function Worksheet(_worksheetImpl) { + var _this = _super.call(this, _worksheetImpl) || this; + _this._worksheetImpl = _worksheetImpl; + // Call to initialize events and then call down to the event listener manager to handle things + _this._worksheetImpl.initializeEvents(_this).forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Object.defineProperty(Worksheet.prototype, "parentDashboard", { + get: function () { + return this._worksheetImpl.parentDashboard; + }, + enumerable: true, + configurable: true + }); + Worksheet.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options); + }; + Worksheet.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) { + return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions); + }; + Worksheet.prototype.clearFilterAsync = function (fieldName) { + return this._worksheetImpl.clearFilterAsync(fieldName); + }; + Worksheet.prototype.getAnalyticObjectsAsync = function () { + throw api_utils_1.TableauException.apiNotImplemented(['getAnalyticObjectsAsync']); + }; + Worksheet.prototype.getDataSourcesAsync = function () { + return this._worksheetImpl.getDataSourcesAsync(); + }; + Worksheet.prototype.getEncodingsAsync = function () { + throw api_utils_1.TableauException.apiNotImplemented(['getEncodingsAsync']); + }; + Worksheet.prototype.getFiltersAsync = function () { + return this._worksheetImpl.getFiltersAsync(); + }; + Worksheet.prototype.getSelectedMarksAsync = function () { + return this._worksheetImpl.getSelectedMarksAsync(); + }; + Worksheet.prototype.getHighlightedMarksAsync = function () { + return this._worksheetImpl.getHighlightedMarksAsync(); + }; + Worksheet.prototype.getSummaryDataAsync = function (options) { + return this._worksheetImpl.getSummaryDataAsync(options); + }; + Worksheet.prototype.getUnderlyingDataAsync = function (options) { + return this._worksheetImpl.getUnderlyingDataAsync(options); + }; + Worksheet.prototype.clearSelectedMarksAsync = function () { + return this._worksheetImpl.clearSelectedMarksAsync(); + }; + Worksheet.prototype.selectMarksByIDAsync = function (marksInfo, updateType) { + return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType); + }; + Worksheet.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) { + return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType); + }; + Worksheet.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) { + return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType); + }; + return Worksheet; + }(Sheet_1.Sheet)); + exports.Worksheet = Worksheet; + + +/***/ }, +/* 27 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var ServiceRegistry_1 = __webpack_require__(28); + var SheetImpl = (function () { + function SheetImpl(_sheetInfoImpl) { + this._sheetInfoImpl = _sheetInfoImpl; + } + Object.defineProperty(SheetImpl.prototype, "name", { + get: function () { + return this._sheetInfoImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "sheetType", { + get: function () { + return this._sheetInfoImpl.sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "sheetPath", { + get: function () { + return this._sheetInfoImpl.sheetPath; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "size", { + get: function () { + return this._sheetInfoImpl.sheetSize; + }, + enumerable: true, + configurable: true + }); + SheetImpl.prototype.findParameterAsync = function (parameterName, sheet) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("parameters-service" /* Parameters */); + return service.findParameterByNameAsync(parameterName, sheet); + }; + SheetImpl.prototype.getParametersAsync = function (sheet) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("parameters-service" /* Parameters */); + return service.getParametersForSheetAsync(this.sheetPath, sheet); + }; + return SheetImpl; + }()); + exports.SheetImpl = SheetImpl; + + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(13); + var ServiceRegistryImpl = (function () { + function ServiceRegistryImpl() { + this._services = {}; + } + ServiceRegistryImpl.prototype.registerService = function (service) { + this._services[service.serviceName] = service; + }; + ServiceRegistryImpl.prototype.getService = function (serviceName) { + if (!this._services.hasOwnProperty(serviceName)) { + throw api_utils_1.TableauException.error(ServiceRegistryImpl.SERVICE_NOT_REGISTERED, [serviceName]); + } + return this._services[serviceName]; + }; + ServiceRegistryImpl.SERVICE_NOT_REGISTERED = 'No Service %1 is registered'; + return ServiceRegistryImpl; + }()); + /** + * static class used for getting access to the single instance + * of the ApiServiceRegistry + */ + var ApiServiceRegistry = (function () { + // Private to avoid anyone constructing this + function ApiServiceRegistry() { + } + Object.defineProperty(ApiServiceRegistry, "instance", { + /** + * Gets the singleton instance of the ServiceRegistry + */ + get: function () { + if (!window.__tableauApiServiceRegistry) { + ApiServiceRegistry.setInstance(new ServiceRegistryImpl()); + } + if (!window.__tableauApiServiceRegistry) { + throw api_utils_1.TableauException.error(ApiServiceRegistry.SERVICE_REGISTRY_FAILED); + } + return window.__tableauApiServiceRegistry; + }, + enumerable: true, + configurable: true + }); + /** + * Helper method to override the registry instance. Can be used by unit tests + * + * @param {ServiceRegistry} serviceRegistry The new registry + */ + ApiServiceRegistry.setInstance = function (serviceRegistry) { + window.__tableauApiServiceRegistry = serviceRegistry; + }; + ApiServiceRegistry.SERVICE_REGISTRY_FAILED = 'Assigning service registry failed'; + return ApiServiceRegistry; + }()); + exports.ApiServiceRegistry = ApiServiceRegistry; + + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_external_contract_1 = __webpack_require__(19); + var SheetInfoImpl = (function () { + function SheetInfoImpl(_name, _sheetType, _sheetSize) { + this._name = _name; + this._sheetType = _sheetType; + this._sheetSize = _sheetSize; + } + Object.defineProperty(SheetInfoImpl.prototype, "name", { + get: function () { + return this._name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetSize", { + get: function () { + return this._sheetSize; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetType", { + get: function () { + return this._sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetPath", { + get: function () { + return { + sheetName: this.name, + isDashboard: this.sheetType === api_external_contract_1.SheetType.Dashboard + // TODO - Stories + }; + }, + enumerable: true, + configurable: true + }); + return SheetInfoImpl; + }()); + exports.SheetInfoImpl = SheetInfoImpl; + + +/***/ }, +/* 30 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var DataSource_1 = __webpack_require__(31); + var DataSourceImpl_1 = __webpack_require__(32); + var SheetImpl_1 = __webpack_require__(27); + var SingleEventManagerImpl_1 = __webpack_require__(37); + var FilterChangedEvent_1 = __webpack_require__(38); + var MarksSelectedEvent_1 = __webpack_require__(42); + var GetDataService_1 = __webpack_require__(43); + var ServiceRegistry_1 = __webpack_require__(28); + var visualIdsAreEqual = function (a, b) { + return a && b && + a.worksheet === b.worksheet && + a.dashboard === b.dashboard && + a.storyboard === b.storyboard && + a.storyPointID === b.storyPointID && + a.flipboardZoneID === b.flipboardZoneID; + }; + var WorksheetImpl = (function (_super) { + __extends(WorksheetImpl, _super); + function WorksheetImpl(sheetInfoImpl, _visualId, _parentDashboard) { + var _this = _super.call(this, sheetInfoImpl) || this; + _this._visualId = _visualId; + _this._parentDashboard = _parentDashboard; + return _this; + } + Object.defineProperty(WorksheetImpl.prototype, "parentDashboard", { + get: function () { + return this._parentDashboard; + }, + enumerable: true, + configurable: true + }); + /** + * Helper method which goes through and registers each event type this impl knows about + * with the NotificationService. It returns an array of SingleEventManager objects which + * can then be passed to an EventListenerManager to handle user registration / unregistration. + * + * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications + * @returns {Array} Collection of event managers to pass to an EventListenerManager + */ + WorksheetImpl.prototype.initializeEvents = function (worksheet) { + var _this = this; + var results = new Array(); + var notificationService; + try { + notificationService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return + return results; + } + // Initialize all of the event managers we'll need (one for each event type) + var marksEvent = new SingleEventManagerImpl_1.SingleEventManagerImpl(Contract.TableauEventType.MarkSelectionChanged); + notificationService.registerHandler(api_internal_contract_1.NotificationId.SelectedMarksChanged, function (model) { + var visualId = model; + return visualIdsAreEqual(visualId, _this.visualId); + }, function (viz) { + marksEvent.triggerEvent(function () { return new MarksSelectedEvent_1.MarksSelectedEvent(worksheet); }); + }); + var filterEvent = new SingleEventManagerImpl_1.SingleEventManagerImpl(Contract.TableauEventType.FilterChanged); + notificationService.registerHandler(api_internal_contract_1.NotificationId.FilterChanged, function (model) { + var filterEventResponse = model; + return _this.visualId.worksheet === filterEventResponse.visualId.worksheet; + }, function (event) { + filterEvent.triggerEvent(function () { return new FilterChangedEvent_1.FilterChangedEvent(worksheet, event.fieldName); }); + }); + results.push(marksEvent); + results.push(filterEvent); + // TODO - other event types + return results; + }; + Object.defineProperty(WorksheetImpl.prototype, "visualId", { + get: function () { + return this._visualId; + }, + enumerable: true, + configurable: true + }); + WorksheetImpl.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options); + }; + WorksheetImpl.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions); + }; + WorksheetImpl.prototype.clearFilterAsync = function (fieldName) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + return service.clearFilterAsync(this.visualId, fieldName); + }; + WorksheetImpl.prototype.getDataSourcesAsync = function () { + var _this = this; + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("data-source-service" /* DataSourceService */); + return service.getDataSourcesAsync().then(function (result) { + var dataSchema = result; + var worksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[_this.name]; + var dataSources = []; + // First, add the primary datasource. By convention, it comes first in the returned array. + var primaryId = worksheetDataSourceInfo.primaryDataSource; + dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[primaryId])); + // Then, loop through any secondary data sources and add them. + for (var _i = 0, _a = worksheetDataSourceInfo.referencedDataSourceList; _i < _a.length; _i++) { + var secondaryId = _a[_i]; + if (secondaryId !== primaryId) { + dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId])); + } + } + return dataSources; + }); + }; + WorksheetImpl.prototype.getFiltersAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + return service.getFiltersAsync(this.visualId); + }; + WorksheetImpl.prototype.getSelectedMarksAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("get-data-service" /* GetData */); + return service.getSelectedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.getHighlightedMarksAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("get-data-service" /* GetData */); + return service.getHighlightedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.getSummaryDataAsync = function (options) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Summary, !!options.ignoreAliases, !!options.ignoreSelection, true, 0); + }; + WorksheetImpl.prototype.getUnderlyingDataAsync = function (options) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Underlying, !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.maxRows || 0); + }; + WorksheetImpl.prototype.clearSelectedMarksAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("selection-service" /* Selection */); + return service.clearSelectedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("selection-service" /* Selection */); + return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType); + }; + WorksheetImpl.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("selection-service" /* Selection */); + return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType); + }; + WorksheetImpl.prototype.createDataSourceFromInfo = function (dataSourceInfo) { + var dataSourceImpl = new DataSourceImpl_1.DataSourceImpl(dataSourceInfo); + var dataSource = new DataSource_1.DataSource(dataSourceImpl); + dataSourceImpl.initializeWithPublicInterfaces(dataSource); + return dataSource; + }; + return WorksheetImpl; + }(SheetImpl_1.SheetImpl)); + exports.WorksheetImpl = WorksheetImpl; + + +/***/ }, +/* 31 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var DataSource = (function () { + function DataSource(_dataSourceImpl) { + this._dataSourceImpl = _dataSourceImpl; + } + Object.defineProperty(DataSource.prototype, "name", { + get: function () { + return this._dataSourceImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "id", { + get: function () { + return this._dataSourceImpl.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "fields", { + get: function () { + return this._dataSourceImpl.fields; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "extractUpdateTime", { + get: function () { + return this._dataSourceImpl.extractUpdateTime; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "isExtract", { + get: function () { + return this._dataSourceImpl.isExtract; + }, + enumerable: true, + configurable: true + }); + DataSource.prototype.refreshAsync = function () { + return this._dataSourceImpl.refreshAsync(); + }; + DataSource.prototype.getActiveTablesAsync = function () { + return this._dataSourceImpl.getActiveTablesAsync(); + }; + DataSource.prototype.getConnectionSummariesAsync = function () { + return this._dataSourceImpl.getConnectionSummariesAsync(); + }; + DataSource.prototype.getUnderlyingDataAsync = function (options) { + return this._dataSourceImpl.getUnderlyingDataAsync(options); + }; + return DataSource; + }()); + exports.DataSource = DataSource; + + +/***/ }, +/* 32 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var FieldImpl_1 = __webpack_require__(33); + var ConnectionSummary_1 = __webpack_require__(34); + var Field_1 = __webpack_require__(35); + var TableSummary_1 = __webpack_require__(36); + var ServiceRegistry_1 = __webpack_require__(28); + var DataSourceImpl = (function () { + function DataSourceImpl(_dataSourceInfo) { + var _this = this; + this._dataSourceInfo = _dataSourceInfo; + this._fields = _dataSourceInfo.fields.map(function (fieldModel) { + var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, _this); + return new Field_1.Field(fieldImpl); + }); + } + Object.defineProperty(DataSourceImpl.prototype, "name", { + get: function () { + return this._dataSourceInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "id", { + get: function () { + return this._dataSourceInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "extractUpdateTime", { + get: function () { + return this._dataSourceInfo.extractUpdateTime; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "fields", { + get: function () { + return this._fields; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "isExtract", { + get: function () { + return this._dataSourceInfo.isExtract; + }, + enumerable: true, + configurable: true + }); + DataSourceImpl.prototype.refreshAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("data-source-service" /* DataSourceService */); + return dataSourceService.refreshAsync(this._dataSourceInfo.id); + }; + DataSourceImpl.prototype.getConnectionSummariesAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("data-source-service" /* DataSourceService */); + return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then(function (summaries) { + return summaries.map(function (summary) { return new ConnectionSummary_1.ConnectionSummary(summary); }); + }); + }; + DataSourceImpl.prototype.getActiveTablesAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("data-source-service" /* DataSourceService */); + return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then(function (tableInfos) { + return tableInfos.map(function (tableInfo) { return new TableSummary_1.TableSummary(tableInfo); }); + }); + }; + DataSourceImpl.prototype.getUnderlyingDataAsync = function (options) { + var defaultOptions = { + ignoreAliases: false, + maxRows: 10000, + columnsToInclude: [], + }; + options = options || {}; + var getDataService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("get-data-service" /* GetData */); + return getDataService.getDataSourceDataAsync(this.id, !!options.ignoreAliases, options.maxRows || defaultOptions.maxRows, options.columnsToInclude || defaultOptions.columnsToInclude); + }; + DataSourceImpl.prototype.initializeWithPublicInterfaces = function (dataSource) { + this._fields = this._dataSourceInfo.fields.map(function (fieldModel) { + var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, dataSource); + return new Field_1.Field(fieldImpl); + }); + }; + return DataSourceImpl; + }()); + exports.DataSourceImpl = DataSourceImpl; + + +/***/ }, +/* 33 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var InternalToExternalEnumMappings_1 = __webpack_require__(23); + var FieldImpl = (function () { + function FieldImpl(_fieldInfo, _parentDataSource) { + this._fieldInfo = _fieldInfo; + this._parentDataSource = _parentDataSource; + } + Object.defineProperty(FieldImpl.prototype, "name", { + get: function () { + return this._fieldInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "id", { + get: function () { + return this._fieldInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "description", { + get: function () { + return this._fieldInfo.description; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "aggregation", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "dataSource", { + get: function () { + return this._parentDataSource; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "role", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isHidden", { + get: function () { + return this._fieldInfo.isHidden; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isGenerated", { + get: function () { + return this._fieldInfo.isGenerated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCalculatedField", { + get: function () { + return this._fieldInfo.isCalculatedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCombinedField", { + get: function () { + return this._fieldInfo.isCombinedField; + }, + enumerable: true, + configurable: true + }); + FieldImpl.prototype.getCalculatedFieldAsync = function () { + throw new Error('Field getCalculatedFieldAsync method not yet implemented.'); + }; + return FieldImpl; + }()); + exports.FieldImpl = FieldImpl; + + +/***/ }, +/* 34 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of a connection summary. + * This does not follow the Impl pattern as it is just a property bag. + */ + var ConnectionSummary = (function () { + function ConnectionSummary(_connectionInfo) { + this._connectionInfo = _connectionInfo; + } + Object.defineProperty(ConnectionSummary.prototype, "name", { + get: function () { + return this._connectionInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "id", { + get: function () { + return this._connectionInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "serverURI", { + get: function () { + return this._connectionInfo.serverURI; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "type", { + get: function () { + return this._connectionInfo.type; + }, + enumerable: true, + configurable: true + }); + return ConnectionSummary; + }()); + exports.ConnectionSummary = ConnectionSummary; + + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(13); + var Field = (function () { + function Field(_fieldImpl) { + this._fieldImpl = _fieldImpl; + } + Object.defineProperty(Field.prototype, "name", { + get: function () { + return this._fieldImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "id", { + get: function () { + return this._fieldImpl.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "description", { + get: function () { + return this._fieldImpl.description; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "aggregation", { + get: function () { + return this._fieldImpl.aggregation; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "dataSource", { + get: function () { + return this._fieldImpl.dataSource; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "role", { + get: function () { + return this._fieldImpl.role; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isHidden", { + get: function () { + return this._fieldImpl.isHidden; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isGenerated", { + get: function () { + return this._fieldImpl.isGenerated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isCalculatedField", { + get: function () { + return this._fieldImpl.isCalculatedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "columnType", { + get: function () { + throw api_utils_1.TableauException.apiNotImplemented(['Field.columnType']); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isCombinedField", { + get: function () { + return this._fieldImpl.isCombinedField; + }, + enumerable: true, + configurable: true + }); + Field.prototype.getCalculatedFieldAsync = function () { + return this._fieldImpl.getCalculatedFieldAsync(); + }; + return Field; + }()); + exports.Field = Field; + + +/***/ }, +/* 36 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of a table summary. + * This does not follow the Impl pattern as it is just a property bag. + */ + var TableSummary = (function () { + function TableSummary(_tableInfo) { + this._tableInfo = _tableInfo; + } + Object.defineProperty(TableSummary.prototype, "name", { + get: function () { + return this._tableInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "id", { + get: function () { + return this._tableInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "connectionId", { + get: function () { + return this._tableInfo.connectionId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "customSQL", { + get: function () { + return this._tableInfo.customSQL; + }, + enumerable: true, + configurable: true + }); + return TableSummary; + }()); + exports.TableSummary = TableSummary; + + +/***/ }, +/* 37 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * This class implements the SingleEventManager interface for a single type of Tableau event + * + * @template TEventType The Tableau event type this class specializes + */ + var SingleEventManagerImpl = (function () { + function SingleEventManagerImpl(eventType) { + this._eventType = eventType; + this._handlers = []; + } + Object.defineProperty(SingleEventManagerImpl.prototype, "eventType", { + get: function () { + return this._eventType; + }, + enumerable: true, + configurable: true + }); + SingleEventManagerImpl.prototype.addEventListener = function (handler) { + var _this = this; + this._handlers.push(handler); + return function () { return _this.removeEventListener(handler); }; + }; + SingleEventManagerImpl.prototype.removeEventListener = function (handler) { + var beforeCount = this._handlers.length; + this._handlers = this._handlers.filter(function (h) { return h !== handler; }); + return beforeCount > this._handlers.length; + }; + SingleEventManagerImpl.prototype.triggerEvent = function (eventGenerator) { + for (var _i = 0, _a = this._handlers; _i < _a.length; _i++) { + var handler = _a[_i]; + try { + var eventModel = eventGenerator(); + handler(eventModel); + } + catch (e) { + // Since this handler could be outside our control, just catch anything it throws and continue on + continue; + } + } + }; + return SingleEventManagerImpl; + }()); + exports.SingleEventManagerImpl = SingleEventManagerImpl; + + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_utils_1 = __webpack_require__(13); + var TableauWorksheetEvent_1 = __webpack_require__(39); + var FilterChangedEvent = (function (_super) { + __extends(FilterChangedEvent, _super); + function FilterChangedEvent(worksheet, _fieldName) { + var _this = _super.call(this, Contract.TableauEventType.FilterChanged, worksheet) || this; + _this._fieldName = _fieldName; + return _this; + } + Object.defineProperty(FilterChangedEvent.prototype, "fieldName", { + get: function () { + return this._fieldName; + }, + enumerable: true, + configurable: true + }); + FilterChangedEvent.prototype.getFilterAsync = function () { + var _this = this; + return this._worksheet.getFiltersAsync().then(function (filters) { + // TODO: Filtering of the filters should eventually be done platform side. + var eventedFilter = filters.find(function (filter) { return (filter.fieldName === _this._fieldName); }); + if (!eventedFilter) { + // We shouldn't hit this unless the filter was removed from the worksheet + // after the event was raised. + throw api_utils_1.TableauException.internalError(['Filter no longer found in worksheet.']); + } + return eventedFilter; + }); + }; + return FilterChangedEvent; + }(TableauWorksheetEvent_1.TableauWorksheetEvent)); + exports.FilterChangedEvent = FilterChangedEvent; + + +/***/ }, +/* 39 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauSheetEvent_1 = __webpack_require__(40); + var TableauWorksheetEvent = (function (_super) { + __extends(TableauWorksheetEvent, _super); + function TableauWorksheetEvent(type, _worksheet) { + var _this = _super.call(this, type, _worksheet) || this; + _this._worksheet = _worksheet; + return _this; + } + Object.defineProperty(TableauWorksheetEvent.prototype, "worksheet", { + get: function () { + return this._worksheet; + }, + enumerable: true, + configurable: true + }); + return TableauWorksheetEvent; + }(TableauSheetEvent_1.TableauSheetEvent)); + exports.TableauWorksheetEvent = TableauWorksheetEvent; + + +/***/ }, +/* 40 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauEvent_1 = __webpack_require__(41); + var TableauSheetEvent = (function (_super) { + __extends(TableauSheetEvent, _super); + function TableauSheetEvent(type, sheet) { + var _this = _super.call(this, type) || this; + _this._sheet = sheet; + return _this; + } + Object.defineProperty(TableauSheetEvent.prototype, "sheet", { + get: function () { + return this._sheet; + }, + enumerable: true, + configurable: true + }); + return TableauSheetEvent; + }(TableauEvent_1.TableauEvent)); + exports.TableauSheetEvent = TableauSheetEvent; + + +/***/ }, +/* 41 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var TableauEvent = (function () { + function TableauEvent(type) { + this._type = type; + } + Object.defineProperty(TableauEvent.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + return TableauEvent; + }()); + exports.TableauEvent = TableauEvent; + + +/***/ }, +/* 42 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var TableauWorksheetEvent_1 = __webpack_require__(39); + var MarksSelectedEvent = (function (_super) { + __extends(MarksSelectedEvent, _super); + function MarksSelectedEvent(worksheet) { + return _super.call(this, Contract.TableauEventType.MarkSelectionChanged, worksheet) || this; + } + MarksSelectedEvent.prototype.getMarksAsync = function () { + return this.worksheet.getSelectedMarksAsync(); + }; + return MarksSelectedEvent; + }(TableauWorksheetEvent_1.TableauWorksheetEvent)); + exports.MarksSelectedEvent = MarksSelectedEvent; + + +/***/ }, +/* 43 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Defines which type of getData call to make. + */ + var GetDataType; + (function (GetDataType) { + GetDataType["Summary"] = "summary"; + GetDataType["Underlying"] = "underlying"; + })(GetDataType = exports.GetDataType || (exports.GetDataType = {})); + + +/***/ }, +/* 44 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var DataSourceServiceImpl_1 = __webpack_require__(45); + var FilterServiceImpl_1 = __webpack_require__(46); + var GetDataServiceImpl_1 = __webpack_require__(50); + var NotificationServiceImpl_1 = __webpack_require__(51); + var ParametersServiceImpl_1 = __webpack_require__(52); + var SelectionServiceImpl_1 = __webpack_require__(56); + var ServiceRegistry_1 = __webpack_require__(28); + function registerAllSharedServices(dispatcher) { + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new DataSourceServiceImpl_1.DataSourceServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new GetDataServiceImpl_1.GetDataServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new FilterServiceImpl_1.FilterServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new NotificationServiceImpl_1.NotificationServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new ParametersServiceImpl_1.ParametersServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.instance.registerService(new SelectionServiceImpl_1.SelectionServiceImpl(dispatcher)); + } + exports.registerAllSharedServices = registerAllSharedServices; + + +/***/ }, +/* 45 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_external_contract_1 = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + var DataSourceServiceImpl = (function () { + function DataSourceServiceImpl(_dispatcher) { + this._dispatcher = _dispatcher; + } + Object.defineProperty(DataSourceServiceImpl.prototype, "serviceName", { + get: function () { + return "data-source-service" /* DataSourceService */; + }, + enumerable: true, + configurable: true + }); + DataSourceServiceImpl.prototype.refreshAsync = function (dataSourceId) { + var parameters = (_a = {}, _a[api_internal_contract_1.ParameterId.DataSourceId] = dataSourceId, _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.RefreshDataSource, parameters).then(function (response) { + return; + }); + var _a; + }; + DataSourceServiceImpl.prototype.getActiveTablesAsync = function (dataSourceId) { + var joinParameters = (_a = {}, _a[api_internal_contract_1.ParameterId.DataSourceId] = dataSourceId, _a); + // Get the description of the tables used by this connection + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetJoinDescription, joinParameters).then(function (joinResponse) { + var joinDescription = joinResponse.result; + // getActiveTables is unsupported for cubes and GA. We do not have a connection type property + // available from the platform (intentionally, to reduce code churn as new connections are added). + // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource. + if (joinDescription.tables.length === 0) { + throw api_utils_1.TableauException.error('getActiveTablesAsync is unsupported for DataSource.', [api_external_contract_1.ErrorCodes.UnsupportedMethodForDataSourceType]); + } + return joinDescription.tables; + }); + var _a; + }; + DataSourceServiceImpl.prototype.getDataSourcesAsync = function () { + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetDataSources, {}).then(function (response) { + var dataSchema = response.result; + return dataSchema; + }); + }; + DataSourceServiceImpl.prototype.getConnectionSummariesAsync = function (dataSourceId) { + var params = (_a = {}, _a[api_internal_contract_1.ParameterId.DataSourceId] = dataSourceId, _a); + // Get the description of the tables used by this connection + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetConnectionDescriptionSummaries, params).then(function (response) { + var descriptionSummaries = response.result; + return descriptionSummaries; + }); + var _a; + }; + return DataSourceServiceImpl; + }()); + exports.DataSourceServiceImpl = DataSourceServiceImpl; + + +/***/ }, +/* 46 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + var ExternalToInternalEnumMappings_1 = __webpack_require__(47); + var InternalToExternalEnumMappings_1 = __webpack_require__(23); + var FilterModels_1 = __webpack_require__(48); + var GetDataModels_1 = __webpack_require__(49); + var FilterServiceImpl = (function () { + function FilterServiceImpl(dispatcher) { + this._dispatcher = dispatcher; + } + Object.defineProperty(FilterServiceImpl.prototype, "serviceName", { + get: function () { + return "filter-service" /* Filter */; + }, + enumerable: true, + configurable: true + }); + FilterServiceImpl.prototype.applyFilterAsync = function (visualId, fieldName, values, updateType, filterOptions) { + if (!api_utils_1.Param.isValidEnumValue(updateType, Contract.FilterUpdateType)) { + throw api_utils_1.TableauException.invalidParamValue(['FilterUpdateType']); + } + var verb = api_internal_contract_1.VerbId.ApplyCategoricalFilter; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_1.ParameterId.FieldName] = fieldName; + parameters[api_internal_contract_1.ParameterId.FilterValues] = values; + parameters[api_internal_contract_1.ParameterId.FilterUpdateType] = updateType; + parameters[api_internal_contract_1.ParameterId.IsExcludeMode] = + (filterOptions === undefined || filterOptions.isExcludeMode === undefined) ? false : filterOptions.isExcludeMode; + return this._dispatcher.execute(verb, parameters).then(function (response) { + var error = response.result; + if (!(error.errorCode === null || error.errorCode === undefined)) { + // TODO: come back and implement error handling logic + throw api_utils_1.TableauException.error(FilterServiceImpl.FILTER_ERROR, [error.errorCode]); + } + return fieldName; + }); + }; + FilterServiceImpl.prototype.applyRangeFilterAsync = function (visualId, fieldName, filterOptions) { + if (!filterOptions) { + throw api_utils_1.TableauException.missingParameter(['RangeFilterOptions']); + } + api_utils_1.Param.verifyRangeParamType(filterOptions.min, filterOptions.max); + var verb = api_internal_contract_1.VerbId.ApplyRangeFilter; + var parameters = {}; + if (filterOptions.min) { + var min = void 0; + if (filterOptions.min instanceof Date) { + min = api_utils_1.Param.serializeDateForPlatform(filterOptions.min); + } + else { + min = filterOptions.min; + } + parameters[api_internal_contract_1.ParameterId.FilterRangeMin] = min; + } + if (filterOptions.max) { + var max = void 0; + if (filterOptions.max instanceof Date) { + max = api_utils_1.Param.serializeDateForPlatform(filterOptions.max); + } + else { + max = filterOptions.max; + } + parameters[api_internal_contract_1.ParameterId.FilterRangeMax] = max; + } + if (filterOptions.nullOption) { + if (!api_utils_1.Param.isValidEnumValue(filterOptions.nullOption, Contract.FilterNullOption)) { + throw api_utils_1.TableauException.invalidParamValue(['NullOption']); + } + parameters[api_internal_contract_1.ParameterId.FilterRangeNullOption] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.nullOptions.convert(filterOptions.nullOption); + } + parameters[api_internal_contract_1.ParameterId.FieldName] = fieldName; + parameters[api_internal_contract_1.ParameterId.VisualId] = visualId; + return this._dispatcher.execute(verb, parameters).then(function (response) { + return fieldName; + }); + }; + FilterServiceImpl.prototype.clearFilterAsync = function (visualId, fieldName) { + var verb = api_internal_contract_1.VerbId.ClearFilter; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_1.ParameterId.FieldName] = fieldName; + return this._dispatcher.execute(verb, parameters).then(function (resposne) { + return fieldName; + }); + }; + FilterServiceImpl.prototype.getFiltersAsync = function (visualId) { + var _this = this; + var verb = api_internal_contract_1.VerbId.GetFilters; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = visualId; + return this._dispatcher.execute(verb, parameters).then(function (response) { + var filters = response.result; + return _this.convertDomainFilters(filters); + }); + }; + FilterServiceImpl.prototype.getCategoricalDomainAsync = function (worksheetName, fieldId, domainType) { + var _this = this; + if (!api_utils_1.Param.isValidEnumValue(domainType, Contract.FilterDomainType)) { + throw new Error('Invalid value for parameter FilterDomainType'); + } + var verb = api_internal_contract_1.VerbId.GetCategoricalDomain; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = { + worksheet: worksheetName + }; + parameters[api_internal_contract_1.ParameterId.FieldId] = fieldId; + parameters[api_internal_contract_1.ParameterId.DomainType] = domainType; + return this._dispatcher.execute(verb, parameters).then(function (response) { + var domain = response.result; + return _this.convertCategoricalDomain(domain, domainType); + }); + }; + FilterServiceImpl.prototype.getRangeDomainAsync = function (worksheetName, fieldId, domainType) { + var _this = this; + if (!api_utils_1.Param.isValidEnumValue(domainType, Contract.FilterDomainType)) { + throw new Error('Invalid value for parameter FilterDomainType'); + } + var verb = api_internal_contract_1.VerbId.GetRangeDomain; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = { + worksheet: worksheetName + }; + parameters[api_internal_contract_1.ParameterId.FieldId] = fieldId; + parameters[api_internal_contract_1.ParameterId.DomainType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterDomainType.convert(domainType); + return this._dispatcher.execute(verb, parameters).then(function (response) { + var domain = response.result; + return _this.convertRangeDomain(domain, domainType); + }); + }; + // Helper Methods + FilterServiceImpl.prototype.convertDomainFilters = function (domainFilters) { + var _this = this; + var filters = []; + domainFilters.forEach(function (domainFilter) { + switch (domainFilter.filterType) { + case api_internal_contract_1.FilterType.Categorical: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertCategoricalFilter(filter)); + } + else { + throw new Error('Invalid Categorical Filter'); + } + break; + } + case api_internal_contract_1.FilterType.Range: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertRangeFilter(filter)); + } + else { + throw new Error('Invalid Range Filter'); + } + break; + } + case api_internal_contract_1.FilterType.RelativeDate: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertRelativeDateFilter(filter)); + } + else { + throw new Error('Invalid Relative Date Filter'); + } + break; + } + default: { + break; + } + } + }); + return filters; + }; + FilterServiceImpl.prototype.convertCategoricalFilter = function (domainFilter) { + var appliedValues = domainFilter.values.map(function (dv) { + return new GetDataModels_1.DataValue(dv.value, dv.formattedValue); + }); + return new FilterModels_1.CategoricalFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, Contract.FilterType.Categorical, appliedValues, domainFilter.isExclude); + }; + FilterServiceImpl.prototype.convertRangeFilter = function (domainFilter) { + var minValue = new GetDataModels_1.DataValue(domainFilter.min.value, domainFilter.min.formattedValue); + var maxValue = new GetDataModels_1.DataValue(domainFilter.max.value, domainFilter.max.formattedValue); + return new FilterModels_1.RangeFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, Contract.FilterType.Range, minValue, maxValue, domainFilter.includeNullValues); + }; + FilterServiceImpl.prototype.convertRelativeDateFilter = function (domainFilter) { + var anchorDateValue = new GetDataModels_1.DataValue(domainFilter.anchorDate.value, domainFilter.anchorDate.formattedValue); + return new FilterModels_1.RelativeDateFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, Contract.FilterType.RelativeDate, anchorDateValue, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(domainFilter.periodType), InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateRangeType.convert(domainFilter.rangeType), domainFilter.rangeN); + }; + FilterServiceImpl.prototype.convertCategoricalDomain = function (domain, domainType) { + var values = domain.values.map(function (domainDv) { + return new GetDataModels_1.DataValue(domainDv.value, domainDv.formattedValue); + }); + return new FilterModels_1.CategoricalDomain(values, domainType); + }; + FilterServiceImpl.prototype.convertRangeDomain = function (domain, domainType) { + var min = new GetDataModels_1.DataValue(domain.min.value, domain.min.formattedValue); + var max = new GetDataModels_1.DataValue(domain.max.value, domain.max.formattedValue); + return new FilterModels_1.RangeDomain(min, max, domainType); + }; + FilterServiceImpl.FILTER_ERROR = 'Error Applying Filter: %1'; + return FilterServiceImpl; + }()); + exports.FilterServiceImpl = FilterServiceImpl; + + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_external_contract_1 = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + /* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */ + /** + * Maps enums used by the external-api-contract to the enums used + * in the internal-api-contract, which developers code against. + */ + var ExternalToInternalEnumMappings = (function () { + function ExternalToInternalEnumMappings() { + } + ExternalToInternalEnumMappings.nullOptions = new api_utils_1.EnumConverter((_a = {}, + _a[api_external_contract_1.FilterNullOption.AllValues] = api_internal_contract_1.FilterNullOption.AllValues, + _a[api_external_contract_1.FilterNullOption.NonNullValues] = api_internal_contract_1.FilterNullOption.NonNullValues, + _a[api_external_contract_1.FilterNullOption.NonNullValues] = api_internal_contract_1.FilterNullOption.NullValues, + _a)); + ExternalToInternalEnumMappings.filterDomainType = new api_utils_1.EnumConverter((_b = {}, + _b[api_external_contract_1.FilterDomainType.Relevant] = api_internal_contract_1.FilterDomainType.Relevant, + _b[api_external_contract_1.FilterDomainType.Database] = api_internal_contract_1.FilterDomainType.Database, + _b)); + return ExternalToInternalEnumMappings; + }()); + exports.ExternalToInternalEnumMappings = ExternalToInternalEnumMappings; + var _a, _b; + /* tslint:enable:typedef */ + + +/***/ }, +/* 48 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var ServiceRegistry_1 = __webpack_require__(28); + var Filter = (function () { + function Filter(_worksheetName, _fieldName, _filterType, _fieldId) { + this._worksheetName = _worksheetName; + this._fieldName = _fieldName; + this._filterType = _filterType; + this._fieldId = _fieldId; + } + Object.defineProperty(Filter.prototype, "worksheetName", { + get: function () { + return this._worksheetName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "fieldName", { + get: function () { + return this._fieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "fieldId", { + get: function () { + return this._fieldId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "filterType", { + get: function () { + return this._filterType; + }, + enumerable: true, + configurable: true + }); + Filter.prototype.getFieldAsync = function () { + throw new Error('Method not implemented'); + }; + return Filter; + }()); + exports.Filter = Filter; + var CategoricalFilter = (function (_super) { + __extends(CategoricalFilter, _super); + function CategoricalFilter(worksheetName, fieldName, fieldId, filterType, _appliedValues, _isExcludeMode) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId) || this; + _this._appliedValues = _appliedValues; + _this._isExcludeMode = _isExcludeMode; + return _this; + } + Object.defineProperty(CategoricalFilter.prototype, "appliedValues", { + get: function () { + return this._appliedValues; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CategoricalFilter.prototype, "isExcludeMode", { + get: function () { + return this._isExcludeMode; + }, + enumerable: true, + configurable: true + }); + CategoricalFilter.prototype.getDomainAsync = function (domainType) { + if (!domainType) { + domainType = Contract.FilterDomainType.Relevant; + } + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType); + }; + return CategoricalFilter; + }(Filter)); + exports.CategoricalFilter = CategoricalFilter; + var RangeFilter = (function (_super) { + __extends(RangeFilter, _super); + function RangeFilter(worksheetName, fieldName, fieldId, filterType, _min, _max, _includeNullValues) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId) || this; + _this._min = _min; + _this._max = _max; + _this._includeNullValues = _includeNullValues; + return _this; + } + Object.defineProperty(RangeFilter.prototype, "minValue", { + get: function () { + return this._min; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeFilter.prototype, "maxValue", { + get: function () { + return this._max; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeFilter.prototype, "includeNullValues", { + get: function () { + return this._includeNullValues; + }, + enumerable: true, + configurable: true + }); + RangeFilter.prototype.getDomainAsync = function (domainType) { + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("filter-service" /* Filter */); + if (!domainType) { + domainType = Contract.FilterDomainType.Relevant; + } + return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType); + }; + return RangeFilter; + }(Filter)); + exports.RangeFilter = RangeFilter; + var RelativeDateFilter = (function (_super) { + __extends(RelativeDateFilter, _super); + function RelativeDateFilter(worksheetName, fieldName, fieldId, filterType, _anchorDate, _periodType, _rangeType, _rangeN) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId) || this; + _this._anchorDate = _anchorDate; + _this._periodType = _periodType; + _this._rangeType = _rangeType; + _this._rangeN = _rangeN; + return _this; + } + Object.defineProperty(RelativeDateFilter.prototype, "anchorDate", { + get: function () { + return this._anchorDate; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "periodType", { + get: function () { + return this._periodType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "rangeType", { + get: function () { + return this._rangeType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "rangeN", { + get: function () { + return this._rangeN; + }, + enumerable: true, + configurable: true + }); + return RelativeDateFilter; + }(Filter)); + exports.RelativeDateFilter = RelativeDateFilter; + var CategoricalDomain = (function () { + function CategoricalDomain(_values, _domainType) { + this._values = _values; + this._domainType = _domainType; + } + Object.defineProperty(CategoricalDomain.prototype, "values", { + get: function () { + return this._values; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CategoricalDomain.prototype, "type", { + get: function () { + return this._domainType; + }, + enumerable: true, + configurable: true + }); + return CategoricalDomain; + }()); + exports.CategoricalDomain = CategoricalDomain; + var RangeDomain = (function () { + function RangeDomain(_min, _max, _domainType) { + this._min = _min; + this._max = _max; + this._domainType = _domainType; + } + Object.defineProperty(RangeDomain.prototype, "type", { + get: function () { + return this._domainType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeDomain.prototype, "min", { + get: function () { + return this._min; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeDomain.prototype, "max", { + get: function () { + return this._max; + }, + enumerable: true, + configurable: true + }); + return RangeDomain; + }()); + exports.RangeDomain = RangeDomain; + + +/***/ }, +/* 49 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var DataTable = (function () { + function DataTable(_data, _columns, _totalRowCount, _isSummaryData, _marksInfo) { + this._data = _data; + this._columns = _columns; + this._totalRowCount = _totalRowCount; + this._isSummaryData = _isSummaryData; + this._marksInfo = _marksInfo; + // TODO: get rid of this in redesign. + this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table'; + } + Object.defineProperty(DataTable.prototype, "name", { + get: function () { + return this._name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "data", { + get: function () { + return this._data; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "columns", { + get: function () { + return this._columns; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "marksInfo", { + get: function () { + return this._marksInfo; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "totalRowCount", { + get: function () { + return this._totalRowCount; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "isSummaryData", { + get: function () { + return this._isSummaryData; + }, + enumerable: true, + configurable: true + }); + return DataTable; + }()); + exports.DataTable = DataTable; + var MarkInfo = (function () { + function MarkInfo(_type, _color, _tupleId) { + this._type = _type; + this._color = _color; + this._tupleId = _tupleId; + } + Object.defineProperty(MarkInfo.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MarkInfo.prototype, "color", { + get: function () { + return this._color; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MarkInfo.prototype, "tupleId", { + get: function () { + return this._tupleId; + }, + enumerable: true, + configurable: true + }); + return MarkInfo; + }()); + exports.MarkInfo = MarkInfo; + var Column = (function () { + function Column(_fieldName, _dataType, // TODO: this shoudl be an enum type + _isReferenced, _index) { + this._fieldName = _fieldName; + this._dataType = _dataType; + this._isReferenced = _isReferenced; + this._index = _index; + } + Object.defineProperty(Column.prototype, "fieldName", { + get: function () { + return this._fieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "dataType", { + get: function () { + return this._dataType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "isReferenced", { + get: function () { + return this._isReferenced; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "index", { + get: function () { + return this._index; + }, + enumerable: true, + configurable: true + }); + return Column; + }()); + exports.Column = Column; + var DataValue = (function () { + /* tslint:disable:no-any */ + function DataValue(_value, _formattedValue) { + this._value = _value; + this._formattedValue = _formattedValue; + } + Object.defineProperty(DataValue.prototype, "value", { + get: function () { + return this._value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataValue.prototype, "formattedValue", { + get: function () { + return this._formattedValue; + }, + enumerable: true, + configurable: true + }); + return DataValue; + }()); + exports.DataValue = DataValue; + + +/***/ }, +/* 50 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var GetDataModels_1 = __webpack_require__(49); + var GetDataService_1 = __webpack_require__(43); + var GetDataServiceImpl = (function () { + function GetDataServiceImpl(dispatcher) { + this._dispatcher = dispatcher; + } + Object.defineProperty(GetDataServiceImpl.prototype, "serviceName", { + get: function () { + return "get-data-service" /* GetData */; + }, + enumerable: true, + configurable: true + }); + GetDataServiceImpl.prototype.getUnderlyingDataAsync = function (visualId, getType, ignoreAliases, ignoreSelection, includeAllColumns, maxRows) { + var _this = this; + // Create all of our parameters + var verb = getType === GetDataService_1.GetDataType.Summary ? api_internal_contract_1.VerbId.GetDataSummaryData : api_internal_contract_1.VerbId.GetUnderlyingData; + var parameters = {}; + parameters[api_internal_contract_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_1.ParameterId.IgnoreAliases] = ignoreAliases; + parameters[api_internal_contract_1.ParameterId.IgnoreSelection] = ignoreSelection; + parameters[api_internal_contract_1.ParameterId.IncludeAllColumns] = includeAllColumns; + parameters[api_internal_contract_1.ParameterId.MaxRows] = maxRows; + return this._dispatcher.execute(verb, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, responseData.isSummary); + }); + }; + GetDataServiceImpl.prototype.getSelectedMarksAsync = function (visualId) { + var _this = this; + var parameters = (_a = {}, _a[api_internal_contract_1.ParameterId.VisualId] = visualId, _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetSelectedMarks, parameters).then(function (response) { + var responseData = response.result; + return { + data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }) + }; + }); + var _a; + }; + GetDataServiceImpl.prototype.getHighlightedMarksAsync = function (visualId) { + var _this = this; + var parameters = (_a = {}, _a[api_internal_contract_1.ParameterId.VisualId] = visualId, _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetHighlightedMarks, parameters).then(function (response) { + var responseData = response.result; + return { + data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }) + }; + }); + var _a; + }; + GetDataServiceImpl.prototype.getDataSourceDataAsync = function (dataSourceId, ignoreAliases, maxRows, columnsToInclude) { + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_1.ParameterId.DataSourceId] = dataSourceId, + _a[api_internal_contract_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_1.ParameterId.MaxRows] = maxRows, + _a[api_internal_contract_1.ParameterId.ColumnsToInclude] = columnsToInclude, + _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.GetDataSourceData, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, false); + }); + var _a; + }; + GetDataServiceImpl.prototype.processResultsTable = function (responseData, isSummary) { + var headers = responseData.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, Contract.DataType.String /*h.DataType*/, h.isReferenced, h.index); }); + // TODO This should be controlled by a flag indicating whether this api will respond marks info or not + var marks; + if (responseData.marks) { + marks = responseData.marks.map(function (h) { return new GetDataModels_1.MarkInfo(h.type, h.color, h.tupleId); }); + } + var table = responseData.dataTable.map(function (row) { + return row.map(function (cell) { + return new GetDataModels_1.DataValue(cell.value, cell.formattedValue); + }); + }); + if (marks) { + return new GetDataModels_1.DataTable(table, headers, table.length, isSummary, marks); + } + return new GetDataModels_1.DataTable(table, headers, table.length, isSummary); + }; + return GetDataServiceImpl; + }()); + exports.GetDataServiceImpl = GetDataServiceImpl; + + +/***/ }, +/* 51 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Registration = (function () { + function Registration(_filterFn, _callbackFn) { + this._filterFn = _filterFn; + this._callbackFn = _callbackFn; + // Nothing Here + } + Registration.prototype.onNotification = function (notificationModel) { + if (this._filterFn(notificationModel)) { + this._callbackFn(notificationModel); + } + }; + return Registration; + }()); + var NotificationServiceImpl = (function () { + function NotificationServiceImpl(dispatcher) { + this.dispatcher = dispatcher; + this._handlers = {}; + this.dispatcher.registerNotificationHandler(this.onNotification.bind(this)); + } + Object.defineProperty(NotificationServiceImpl.prototype, "serviceName", { + get: function () { + return "notification-service" /* Notification */; + }, + enumerable: true, + configurable: true + }); + NotificationServiceImpl.prototype.registerHandler = function (id, filterFn, handler) { + var _this = this; + var handlers = this._handlers[id] || new Array(); + var registration = new Registration(filterFn, handler); + handlers.push(registration); + this._handlers[id] = handlers; + return function () { return _this.removeRegistration(id, registration); }; + }; + NotificationServiceImpl.prototype.hasHandlersForNotificationType = function (id) { + return this._handlers.hasOwnProperty(id); + }; + NotificationServiceImpl.prototype.onNotification = function (notification) { + if (!this.hasHandlersForNotificationType(notification.notificationId)) { + return; + } + // Go through and check for all the handlers of this particular notification + this._handlers[notification.notificationId].forEach(function (h) { return h.onNotification(notification.data); }); + }; + NotificationServiceImpl.prototype.removeRegistration = function (id, registration) { + if (!this.hasHandlersForNotificationType(id)) { + return; + } + this._handlers[id] = this._handlers[id].filter(function (reg) { return reg !== registration; }); + }; + return NotificationServiceImpl; + }()); + exports.NotificationServiceImpl = NotificationServiceImpl; + + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + var ParameterImpl_1 = __webpack_require__(53); + var Parameter_1 = __webpack_require__(55); + var ParametersServiceImpl = (function () { + function ParametersServiceImpl(dispatcher) { + this.dispatcher = dispatcher; + } + Object.defineProperty(ParametersServiceImpl.prototype, "serviceName", { + get: function () { + return "parameters-service" /* Parameters */; + }, + enumerable: true, + configurable: true + }); + ParametersServiceImpl.prototype.getParametersForSheetAsync = function (sheetPath, sheet) { + var parameters = (_a = {}, + _a[api_internal_contract_1.ParameterId.SheetPath] = sheetPath, + _a); + return this.dispatcher.execute(api_internal_contract_1.VerbId.GetParametersForSheet, parameters).then(function (response) { + // TODO - Check for error + var result = response.result; + return result.map(function (parameterInfo) { + var impl = new ParameterImpl_1.ParameterImpl(parameterInfo); + return new Parameter_1.Parameter(impl, sheet); + }); + }); + var _a; + }; + ParametersServiceImpl.prototype.changeParameterValueAsync = function (fieldName, newValue) { + var parameters = (_a = {}, + _a[api_internal_contract_1.ParameterId.ParameterFieldName] = fieldName, + _a[api_internal_contract_1.ParameterId.ParameterValue] = newValue, + _a); + return this.dispatcher.execute(api_internal_contract_1.VerbId.ChangeParameterValue, parameters).then(function (response) { + var result = response.result; + return result; + }); + var _a; + }; + ParametersServiceImpl.prototype.findParameterByNameAsync = function (name, sheet) { + return this.findParameterAsync(sheet, name, undefined); + }; + ParametersServiceImpl.prototype.findParameterByGlobalFieldNameAsync = function (fieldName, sheet) { + return this.findParameterAsync(sheet, undefined, fieldName); + }; + ParametersServiceImpl.prototype.findParameterAsync = function (sheet, name, fieldName) { + var parameters = {}; + if (name !== undefined) { + parameters[api_internal_contract_1.ParameterId.ParameterCaption] = name; + } + else if (fieldName !== undefined) { + parameters[api_internal_contract_1.ParameterId.ParameterFieldName] = fieldName; + } + else { + throw api_utils_1.TableauException.missingParameter(['field name or caption']); + } + return this.dispatcher.execute(api_internal_contract_1.VerbId.FindParameter, parameters).then(function (response) { + var instanceOfParameterInfo = function (object) { + return 'fieldName' in object; + }; + // We need to check to see if we got a valid response back again + if (instanceOfParameterInfo(response.result)) { + var result = response.result; + var impl = new ParameterImpl_1.ParameterImpl(result); + return new Parameter_1.Parameter(impl, sheet); + } + else { + return undefined; + } + }); + }; + return ParametersServiceImpl; + }()); + exports.ParametersServiceImpl = ParametersServiceImpl; + + +/***/ }, +/* 53 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + var InternalToExternalEnumMappings_1 = __webpack_require__(23); + var ParameterChangedEvent_1 = __webpack_require__(54); + var GetDataModels_1 = __webpack_require__(49); + var ServiceRegistry_1 = __webpack_require__(28); + var SingleEventManagerImpl_1 = __webpack_require__(37); + var ParameterImpl = (function () { + function ParameterImpl(parameterInfo) { + this.setParameterInfo(parameterInfo); + } + Object.defineProperty(ParameterImpl.prototype, "name", { + get: function () { + return this._parameterInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "currentValue", { + get: function () { + return new GetDataModels_1.DataValue(this._parameterInfo.currentValue.value, this._parameterInfo.currentValue.formattedValue); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "dataType", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "id", { + get: function () { + return this._globalFieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "allowableValues", { + get: function () { + return this._allowableValues; + }, + enumerable: true, + configurable: true + }); + ParameterImpl.prototype.changeValueAsync = function (newValue) { + var _this = this; + var coercedValue = api_utils_1.Param.serializeParamterValue(newValue); + var parametersService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("parameters-service" /* Parameters */); + return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then(function (parameterInfo) { + _this.setParameterInfo(parameterInfo); + return _this.currentValue; + }); + }; + /** + * Helper method which goes through and registers each event type this impl knows about + * with the NotificationService. It returns an array of SingleEventManager objects which + * can then be passed to an EventListenerManager to handle user registration / unregistration. + * + * @param sheet The sheet object which will be included with the event notifications + * @returns {Array} Collection of event managers to pass to an EventListenerManager + */ + ParameterImpl.prototype.initializeEvents = function (sheet) { + var _this = this; + var results = new Array(); + var notificationService; + try { + notificationService = ServiceRegistry_1.ApiServiceRegistry.instance.getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return + return results; + } + // Initialize all of the event managers we'll need (one for each event type) + var parameterEvent = new SingleEventManagerImpl_1.SingleEventManagerImpl(Contract.TableauEventType.ParameterChanged); + notificationService.registerHandler(api_internal_contract_1.NotificationId.ParameterChanged, function (model) { + var fieldName = model; + return fieldName === _this._globalFieldName; + }, function (fieldName) { + parameterEvent.triggerEvent(function () { return new ParameterChangedEvent_1.ParameterChangedEvent(fieldName, sheet); }); + }); + results.push(parameterEvent); + return results; + }; + ParameterImpl.prototype.setParameterInfo = function (parameterInfo) { + this._parameterInfo = parameterInfo; + this._globalFieldName = parameterInfo.fieldName; + var type = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType); + var listValues; + var minValue; + var maxValue; + var stepSize; + var dateStepPeriod; + if (type === Contract.ParameterValueType.List) { + var values = parameterInfo.allowableValues || []; + listValues = values.map(function (val) { return new GetDataModels_1.DataValue(val.value, val.formattedValue); }); + } + else if (type === Contract.ParameterValueType.Range) { + minValue = parameterInfo.minValue && new GetDataModels_1.DataValue(parameterInfo.minValue.value, parameterInfo.minValue.formattedValue); + maxValue = parameterInfo.maxValue && new GetDataModels_1.DataValue(parameterInfo.maxValue.value, parameterInfo.maxValue.formattedValue); + stepSize = parameterInfo.stepSize; + dateStepPeriod = parameterInfo.dateStepPeriod && + InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod); + } + this._allowableValues = { + type: type, + allowableValues: listValues, + minValue: minValue, + maxValue: maxValue, + stepSize: stepSize, + dateStepPeriod: dateStepPeriod + }; + }; + return ParameterImpl; + }()); + exports.ParameterImpl = ParameterImpl; + + +/***/ }, +/* 54 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_utils_1 = __webpack_require__(13); + var ServiceRegistry_1 = __webpack_require__(28); + var TableauSheetEvent_1 = __webpack_require__(40); + var ParameterChangedEvent = (function (_super) { + __extends(ParameterChangedEvent, _super); + function ParameterChangedEvent(_globalFieldName, sheet) { + var _this = _super.call(this, Contract.TableauEventType.ParameterChanged, sheet) || this; + _this._globalFieldName = _globalFieldName; + return _this; + } + ParameterChangedEvent.prototype.getParameterAsync = function () { + // Call down to our service to get the parameter back via its field name + var service = ServiceRegistry_1.ApiServiceRegistry.instance.getService("parameters-service" /* Parameters */); + return service.findParameterByGlobalFieldNameAsync(this._globalFieldName, this.sheet).then(function (parameter) { + if (parameter === undefined) { + throw api_utils_1.TableauException.error(ParameterChangedEvent.PARAM_NOT_FOUND); + } + return parameter; + }); + }; + ParameterChangedEvent.PARAM_NOT_FOUND = 'Unable to find parameter'; + return ParameterChangedEvent; + }(TableauSheetEvent_1.TableauSheetEvent)); + exports.ParameterChangedEvent = ParameterChangedEvent; + + +/***/ }, +/* 55 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + var EventListenerManager_1 = __webpack_require__(12); + /** + * Implementation of the Parameter contract. Calls down to the impl + * class for almost all of the work it does. + */ + var Parameter = (function (_super) { + __extends(Parameter, _super); + function Parameter(parameterImpl, sheet) { + var _this = _super.call(this) || this; + _this.parameterImpl = parameterImpl; + // Initialize our event handling for this class + _this.parameterImpl.initializeEvents(sheet).forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Object.defineProperty(Parameter.prototype, "name", { + get: function () { + return this.parameterImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "currentValue", { + get: function () { + return this.parameterImpl.currentValue; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "dataType", { + get: function () { + return this.parameterImpl.dataType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "allowableValues", { + get: function () { + return this.parameterImpl.allowableValues; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "id", { + get: function () { + return this.parameterImpl.id; + }, + enumerable: true, + configurable: true + }); + Parameter.prototype.changeValueAsync = function (newValue) { + return this.parameterImpl.changeValueAsync(newValue); + }; + return Parameter; + }(EventListenerManager_1.EventListenerManager)); + exports.Parameter = Parameter; + + +/***/ }, +/* 56 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Contract = __webpack_require__(19); + var api_internal_contract_1 = __webpack_require__(21); + var api_utils_1 = __webpack_require__(13); + var SelectionModels_1 = __webpack_require__(57); + var SelectionServiceImpl = (function () { + function SelectionServiceImpl(dispatcher) { + this._dispatcher = dispatcher; + } + Object.defineProperty(SelectionServiceImpl.prototype, "serviceName", { + get: function () { + return "selection-service" /* Selection */; + }, + enumerable: true, + configurable: true + }); + /** + * Method to clear all the selected marks for the given worksheet. + * + * @param visualId + */ + SelectionServiceImpl.prototype.clearSelectedMarksAsync = function (visualId) { + var parameters = (_a = {}, _a[api_internal_contract_1.ParameterId.VisualId] = visualId, _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.ClearSelectedMarks, parameters).then(function (response) { + return; // Expecting an empty model and hence the void response. + }); + var _a; + }; + /** + * Method to select marks for the given worksheet. + * + * @param visualId + * @param selectionCriteria + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.selectMarksByValueAsync = function (visualId, selectionCriterias, selectionUpdateType) { + if (selectionCriterias.length === 0) { + throw api_utils_1.TableauException.invalid(['Selection criteria', 'Selections missing.']); + } + var selectionType = this.validateSelectionUpdateType(selectionUpdateType); + var selectionCriteriaType = this.validateSelectionCriteria(selectionCriterias[0]); + var selectionModelContainer = this.parseSelectionMarks(selectionCriterias, selectionCriteriaType); + var parameters = (_a = {}, + _a[api_internal_contract_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_1.ParameterId.SelectionUpdateType] = selectionType, + _a); + switch (selectionCriteriaType) { + case SelectionCriteriaType.HierarchicalType: { + parameters[api_internal_contract_1.ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr; + break; + } + case SelectionCriteriaType.RangeType: { + parameters[api_internal_contract_1.ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr; + break; + } + case SelectionCriteriaType.DimensionType: { + parameters[api_internal_contract_1.ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr; + break; + } + default: + break; + } + return this._dispatcher.execute(api_internal_contract_1.VerbId.SelectByValue, parameters).then(function (response) { + // Expecting an empty model and hence the void response. + return; + // TODO Investigate the error response with multiple output params and throw error accordingly. + }); + var _a; + }; + /** + * Method to select marks for the given worksheet. + * + * @param visualId + * @param MarkInfo + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.selectMarksByIdAsync = function (visualId, marks, selectionUpdateType) { + if (marks.length === 0) { + throw api_utils_1.TableauException.invalid(['Selection', 'Marks info missing.']); + } + var selectionType = this.validateSelectionUpdateType(selectionUpdateType); + var selectionModelContainer = this.parseSelectionIds(marks); + var parameters = (_a = {}, + _a[api_internal_contract_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_1.ParameterId.SelectionUpdateType] = selectionType, + _a[api_internal_contract_1.ParameterId.Selection] = selectionModelContainer.selection, + _a); + return this._dispatcher.execute(api_internal_contract_1.VerbId.SelectByValue, parameters).then(function (response) { + // Expecting an empty model and hence the void response. + return; + // TODO Investigate the error response with multiple output params and throw error accordingly. + }); + var _a; + }; + /** + * Method to prepare the pres models for selection by MarksInfo + * @param marks + */ + SelectionServiceImpl.prototype.parseSelectionIds = function (marks) { + var ids = []; + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + for (var i = 0; i < marks.length; i++) { + var tupleId = marks[i].tupleId; + if (tupleId !== undefined && tupleId !== null) { + ids.push(tupleId.toString()); // collect the tuple ids + } + else { + throw api_utils_1.TableauException.invalid(['tupleId']); + } + } + if (ids.length !== 0) { + var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel(); + tupleSelectionModel.selectionType = 'tuples'; + tupleSelectionModel.objectIds = ids; + selectionModelContainer.selection = tupleSelectionModel; + } + return selectionModelContainer; + }; + /** + * Method to prepare the pres models for selection by values. + * + * Supports 3 types for selection: + * 1) hierarchical value based selection + * 2) range value based selection + * 3) Dimension value based selection + * + * @param marks + * @param hierModelArr + * @param dimModelArr + * @param quantModelArr + * @param selection + */ + SelectionServiceImpl.prototype.parseSelectionMarks = function (selectionCriterias, selectionType) { + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + var mixedSelectionsError = false; + for (var i = 0; i < selectionCriterias.length; i++) { + var st = selectionCriterias[i]; + if (st.fieldName && (st.value !== undefined && st.value !== null)) { + var catRegex = new RegExp('(\[[A-Za-z0-9]+]).*', 'g'); + var rangeOption = st.value; + if (catRegex.test(st.fieldName)) { + if (selectionType === SelectionCriteriaType.HierarchicalType) { + var hierModel = this.addToParamsList(st.fieldName, st.value); + selectionModelContainer.hierModelArr.push(hierModel); + } + else { + mixedSelectionsError = true; + break; + } + } + else if (rangeOption.min !== undefined + && rangeOption.max !== undefined) { + if (selectionType === SelectionCriteriaType.RangeType) { + var quantModel = this.addToRangeParamsList(st.fieldName, rangeOption); + selectionModelContainer.quantModelArr.push(quantModel); + } + else { + mixedSelectionsError = true; + break; + } + } + else { + if (selectionType === SelectionCriteriaType.DimensionType) { + var dimModel = this.addToParamsList(st.fieldName, st.value); + selectionModelContainer.dimModelArr.push(dimModel); + } + else { + mixedSelectionsError = true; + break; + } + } + } + } + if (mixedSelectionsError) { + throw api_utils_1.TableauException.invalid(['Selection Criteria', 'Different types of selection criterias provided.']); + } + return selectionModelContainer; + }; + /** + * + * @param selectionCriterias Validate and determine the selection criterias type. + */ + SelectionServiceImpl.prototype.validateSelectionCriteria = function (selectionCriteria) { + var selectionType; + // Determine the type of selection, this command is by looking at the first selection + var crit = selectionCriteria; + var catRegex = new RegExp('(\[[A-Za-z0-9]+]).*', 'g'); + var rangeOption = crit.value; + if (crit.fieldName && (crit.value !== undefined && crit.value !== null)) { + if (catRegex.test(crit.fieldName)) { + selectionType = SelectionCriteriaType.HierarchicalType; + } + else if (rangeOption.min !== undefined + && rangeOption.max !== undefined) { + selectionType = SelectionCriteriaType.RangeType; + } + else { + selectionType = SelectionCriteriaType.DimensionType; + } + } + else { + throw api_utils_1.TableauException.invalid(['Selection', 'Criteria format.']); + } + return selectionType; + }; + /** + * Method to transform the key value pair into value based pres model object. + * + * @param valueSelectionModel + * @param fieldName + * @param value + */ + SelectionServiceImpl.prototype.addToParamsList = function (fieldName, value) { + var valueSelectionModel = new SelectionModels_1.ValueSelectionModel(); + var markValues = []; + if (value instanceof Array) { + var valueArr = value; + for (var i = 0; i < valueArr.length; i++) { + markValues.push(valueArr[i].toString()); + } + } + else { + markValues.push(value.toString()); + } + valueSelectionModel.qualifiedFieldCaption = fieldName; + valueSelectionModel.selectValues = markValues; + return valueSelectionModel; + }; + /** + * Method to transform the key value pair into range based selection pres model. + * + * TODO: Need to handle the parsing of date type values. + * + * @param valueSelectionModel + * @param fieldName + * @param value + */ + SelectionServiceImpl.prototype.addToRangeParamsList = function (fieldName, value) { + var rangeSelectionModel = new SelectionModels_1.RangeSelectionModel(); + rangeSelectionModel.qualifiedFieldCaption = fieldName; + if (value.max !== undefined && value.max !== null) { + rangeSelectionModel.maxValue = value.max.toString(); + } + if (value.min !== undefined && value.min !== null) { + rangeSelectionModel.minValue = value.min.toString(); + } + rangeSelectionModel.included = this.validateNullOptionType(value.nullOption); + return rangeSelectionModel; + }; + /** + * Method to validate the selection update type. + * + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.validateSelectionUpdateType = function (selectionUpdateType) { + if (selectionUpdateType === Contract.SelectionUpdateType.Replace) { + return api_internal_contract_1.SelectionUpdateType.Replace; + } + else if (selectionUpdateType === Contract.SelectionUpdateType.Add) { + return api_internal_contract_1.SelectionUpdateType.Add; + } + else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) { + return api_internal_contract_1.SelectionUpdateType.Remove; + } + return api_internal_contract_1.SelectionUpdateType.Replace; + }; + /** + * Method to validate the include type for range selection. + * + * @param nullOption + */ + SelectionServiceImpl.prototype.validateNullOptionType = function (nullOption) { + if (nullOption) { + if (nullOption === Contract.FilterNullOption.NullValues) { + return api_internal_contract_1.QuantitativeIncludedValues.IncludeNull; + } + else if (nullOption === Contract.FilterNullOption.NonNullValues) { + return api_internal_contract_1.QuantitativeIncludedValues.IncludeNonNull; + } + else if (nullOption === Contract.FilterNullOption.AllValues) { + return api_internal_contract_1.QuantitativeIncludedValues.IncludeAll; + } + } + return api_internal_contract_1.QuantitativeIncludedValues.IncludeAll; + }; + return SelectionServiceImpl; + }()); + exports.SelectionServiceImpl = SelectionServiceImpl; + /** + * Enum for the different selection criteria types. + */ + var SelectionCriteriaType; + (function (SelectionCriteriaType) { + SelectionCriteriaType[SelectionCriteriaType["HierarchicalType"] = 1] = "HierarchicalType"; + SelectionCriteriaType[SelectionCriteriaType["RangeType"] = 2] = "RangeType"; + SelectionCriteriaType[SelectionCriteriaType["DimensionType"] = 3] = "DimensionType"; + SelectionCriteriaType[SelectionCriteriaType["TuplesType"] = 4] = "TuplesType"; + })(SelectionCriteriaType || (SelectionCriteriaType = {})); + + +/***/ }, +/* 57 */ +/***/ function(module, exports) { + + "use strict"; + var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })(); + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Selection Model. + */ + var SelectionModel = (function () { + function SelectionModel() { + } + return SelectionModel; + }()); + exports.SelectionModel = SelectionModel; + /** + * Value based selection model. Meant for hierarchical, range and categorical selections. + */ + var ValueSelectionModel = (function (_super) { + __extends(ValueSelectionModel, _super); + function ValueSelectionModel() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.selectValues = []; + return _this; + } + return ValueSelectionModel; + }(SelectionModel)); + exports.ValueSelectionModel = ValueSelectionModel; + /** + * Hierarchical value selection model + */ + var HierarchicalSelectionModel = (function (_super) { + __extends(HierarchicalSelectionModel, _super); + function HierarchicalSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return HierarchicalSelectionModel; + }(ValueSelectionModel)); + exports.HierarchicalSelectionModel = HierarchicalSelectionModel; + /** + * Range based value selection model + */ + var RangeSelectionModel = (function (_super) { + __extends(RangeSelectionModel, _super); + function RangeSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return RangeSelectionModel; + }(SelectionModel)); + exports.RangeSelectionModel = RangeSelectionModel; + /** + * Dimension value selection model + */ + var DimensionSelectionModel = (function (_super) { + __extends(DimensionSelectionModel, _super); + function DimensionSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return DimensionSelectionModel; + }(ValueSelectionModel)); + exports.DimensionSelectionModel = DimensionSelectionModel; + /** + * Tuple based selection model + */ + var TupleSelectionModel = (function () { + function TupleSelectionModel() { + this.objectIds = []; + } + return TupleSelectionModel; + }()); + exports.TupleSelectionModel = TupleSelectionModel; + /** + * Container class to populate all the selection models when parsing input + */ + var SelectionModelsContainer = (function () { + function SelectionModelsContainer() { + this.hierModelArr = []; + this.dimModelArr = []; + this.quantModelArr = []; + } + return SelectionModelsContainer; + }()); + exports.SelectionModelsContainer = SelectionModelsContainer; + + +/***/ }, +/* 58 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_messaging_1 = __webpack_require__(59); + var CrossFrameDispatcher_1 = __webpack_require__(65); + // Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153 + function inIframe(thisWindow) { + try { + return thisWindow.self !== thisWindow.parent; + } + catch (e) { + return true; + } + } + /** + * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running + * + * @param thisWindow The window which we are running in (injected for unit testing purposes) + * @param versionNumber The version number of our API to include in the initialization message + * @returns A promise which is doing the actual bootstrapping + */ + function doCrossFrameBootstrap(thisWindow, versionNumber) { + return new Promise(function (resolve, reject) { + // Check to make sure we're in an iframe and have a parent to communicate with + if (!inIframe(thisWindow)) { + reject('This extension is not running inside an iframe or desktop. Initialization failed.'); + } + // Create the messenger which will do he communication between this window and our parent + // Since we don't know where we are running yet, we have to make this initial origin '*'. Once + // we have successfully initialized our extension, we will limit where we send messages + var messenger = new api_messaging_1.CrossFrameMessenger(thisWindow, thisWindow.parent, '*'); + // Prepare to send an initialization message to the parent frame + var initializationMessage = messenger.prepareInitializationMessage(versionNumber, api_messaging_1.VERSION); + // When we receive a response back from the parent, we check to make sure the guids match and then we know + // that the parent is aware of us and we can start communicating + messenger.setCommandResponseMessageHandler(function (msg) { + // Verify we are getting a response from our initialize message + if (msg.commandGuid === initializationMessage.messageGuid) { + var dispatcher = new CrossFrameDispatcher_1.CrossFrameDispatcher(messenger); + resolve(dispatcher); + } + }); + // Now that our handlers are ready, start listening and send our initialization message + messenger.startListening(); + initializationMessage.send(); + }); + } + exports.doCrossFrameBootstrap = doCrossFrameBootstrap; + + +/***/ }, +/* 59 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(60)); + __export(__webpack_require__(63)); + // Export the version number of messaging for consumers to use. + // Be very careful making any updates to this contract which break version compatibility. + exports.VERSION = { + major: 1, + minor: 0, + fix: 0 + }; + + +/***/ }, +/* 60 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var guid_1 = __webpack_require__(61); + var CrossFramePreparedMessage_1 = __webpack_require__(62); + var MessageTypes_1 = __webpack_require__(63); + var MessageTypeChecks_1 = __webpack_require__(64); + /** + * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of + * this class can be instantiated on both sides of a frame boundary to facilitate communication + * in both directions between the frames. This class implements both the dispatcher and the listener + * portions, but doesn't require callers to care about both. + */ + var CrossFrameMessenger = (function () { + /** + * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener, + * be sure to call StartListening and register message handlers. + * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here. + * @param [otherWindow] Optional otherWindow which messages will be posted to. + * If defined, incoming messages must originate from otherWindow to be passed on + * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages. + * This value will be sent as the targetOrigin of a postMessage + * (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) + */ + function CrossFrameMessenger(thisWindow, otherWindow, otherWindowOrigin) { + this.thisWindow = thisWindow; + this.otherWindow = otherWindow; + this.otherWindowOrigin = otherWindowOrigin; + // Make sure to call StartListening + } + ///// MessageListener Implementation + CrossFrameMessenger.prototype.startListening = function () { + var _this = this; + // Check if we already are listening, if not, hook up a message listener + if (!this.unregisterFunction) { + var boundHandler_1 = this.onMessageReceived.bind(this); + this.thisWindow.addEventListener('message', boundHandler_1, true); + this.unregisterFunction = function () { return _this.thisWindow.removeEventListener('message', boundHandler_1, true); }; + } + }; + CrossFrameMessenger.prototype.stopListening = function () { + // Stop listening if we have started listening + if (this.unregisterFunction) { + this.unregisterFunction(); + this.unregisterFunction = undefined; + } + }; + CrossFrameMessenger.prototype.setInitializeMessageHandler = function (handler) { + this.initializeMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setCommandResponseMessageHandler = function (handler) { + this.commandResponseMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setCommandMessageHandler = function (handler) { + this.commandMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setNotificationMessageHandler = function (handler) { + this.notificationMessageHandler = handler; + }; + ///// MessageDispatcher Implementation + CrossFrameMessenger.prototype.prepareInitializationMessage = function (apiVersion, crossFrameVersion) { + var message = { + msgGuid: guid_1.Guid.create().formattedValue, + msgType: MessageTypes_1.MessageType.Initialize, + crossFrameVersion: crossFrameVersion, + apiVersion: apiVersion + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareCommandMessage = function (verbId, parameters) { + var message = { + msgGuid: guid_1.Guid.create().formattedValue, + msgType: MessageTypes_1.MessageType.Command, + verbId: verbId, + parameters: parameters + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareCommandResponseMessage = function (commandGuid, data, error) { + var message = { + msgGuid: guid_1.Guid.create().formattedValue, + msgType: MessageTypes_1.MessageType.CommandResponse, + commandGuid: commandGuid, + data: data, + error: error + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareNotificationMessage = function (notificationId, data) { + var message = { + msgGuid: guid_1.Guid.create().formattedValue, + msgType: MessageTypes_1.MessageType.Notification, + notificationId: notificationId, + data: data + }; + return this.prepareMessage(message); + }; + /** + * Prepares a pending message for sending and returns the prepared message + * + * @param msg The message to be sent to this.otherWindow + * @returns The prepared message + */ + CrossFrameMessenger.prototype.prepareMessage = function (msg) { + if (!this.otherWindow || !this.otherWindowOrigin) { + throw 'Other window not initialized, cannot dispatch messages'; + } + var preparedMessage = new CrossFramePreparedMessage_1.CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin); + return preparedMessage; + }; + /** + * Called when a message is received. Does some validation of the message, and then + * calls an appropriate message handler if one is defined + * + * @param event The incoming MessageEvent + */ + CrossFrameMessenger.prototype.onMessageReceived = function (event) { + // If we have an otherWindow defined, make sure the message is coming from there + if (this.otherWindow && event.source !== this.otherWindow) { + return; + } + // Do some validation on event.data to make sure that we have received a real message + if (!event.data) { + return; + } + var message = event.data; + if (!MessageTypeChecks_1.isMessage(message)) { + return; + } + // Check the declared message type, validate the message, and call an appropriate hander if one exists + switch (message.msgType) { + case MessageTypes_1.MessageType.Initialize: { + if (!MessageTypeChecks_1.isInitMessage(message) || !this.initializeMessageHandler) { + return; + } + this.initializeMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.CommandResponse: { + if (!MessageTypeChecks_1.isCommandResponseMessage(message) || !this.commandResponseMessageHandler) { + return; + } + this.commandResponseMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.Command: { + if (!MessageTypeChecks_1.isCommandMessage(message) || !this.commandMessageHandler) { + return; + } + this.commandMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.Notification: { + if (!MessageTypeChecks_1.isNotificationMessage(message) || !this.notificationMessageHandler) { + return; + } + this.notificationMessageHandler(message, event.source); + break; + } + default: + } + }; + return CrossFrameMessenger; + }()); + exports.CrossFrameMessenger = CrossFrameMessenger; + + +/***/ }, +/* 61 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var guidRegex = /^[a-f0-9]{8}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{12}$/i; + var emptyGuidValue = '00000000-0000-0000-0000-000000000000'; + /** + * This is where the magic happens. Generates the specified number of GUID quads using a random number. + * @param count The number of quads to generate. + */ + function generateQuad(count) { + if (count === void 0) { count = 1; } + var out = ''; + for (var i = 0; i < count; i++) { + // tslint:disable-next-line:no-bitwise + out += (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1); + } + return out; + } + /** + * Represents a Globally Unique Identifier (GUID). This is not meant to be cryptographically secure. + */ + var Guid = (function () { + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Constructor + function Guid(value) { + this.value = value.toLowerCase(); + } + Object.defineProperty(Guid.prototype, "formattedValue", { + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Properties + /** + * Read-only formatted value of the GUID. + */ + get: function () { + return this.value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Guid.prototype, "isEmpty", { + /** + * Returns a value indicating whether this GUID is empty (equal to Guid.EMPTY). + */ + get: function () { + return this.value === emptyGuidValue; + }, + enumerable: true, + configurable: true + }); + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Methods + /** + * Returns a value indicating whether the value is a valid GUID. + * @param value Either a Guid instance or a string + */ + Guid.isGuid = function (value) { + return (value instanceof Guid) || guidRegex.test(value); + }; + /** + * Creates a new GUID. + */ + Guid.create = function () { + return new Guid([generateQuad(2), generateQuad(), generateQuad(), generateQuad(), generateQuad(3)].join('-')); + }; + /** + * Parses an existing GUID string. Throws a TypeError if the value is not a valid GUID. + * @param value the existing GUID string to parse + */ + Guid.parse = function (value) { + if (!Guid.isGuid(value)) { + throw new TypeError("Value is not a valid GUID: '" + value + "'"); + } + return new Guid(value); + }; + /** + * Returns the formatted GUID. + */ + Guid.prototype.toString = function () { + return this.value; + }; + /** + * Returns a value indicating whether another GUID is equal to this GUID. + * @param other Either another Guid instance or a formatted GUID string. + */ + Guid.prototype.equals = function (other) { + var otherGuid = (other instanceof Guid) ? other : Guid.parse(other); + return this.formattedValue === otherGuid.formattedValue; + }; + /** + * Represents a placeholder GUID or a value to represent a non-GUID. + * Returns '00000000-0000-0000-0000-000000000000'. + */ + Guid.EMPTY = new Guid(emptyGuidValue); + return Guid; + }()); + exports.Guid = Guid; + + +/***/ }, +/* 62 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the PreparedMessage interface used to post messages between + * two frames using window.postMessage + */ + var CrossFramePreparedMessage = (function () { + /** + * Creates an instance of CrossFramePreparedMessage. + * @param _message The message to be sent + * @param _target The target window where the message will be sent + * @param _origin The targetOrigin where this message can be received + */ + function CrossFramePreparedMessage(_message, _target, _origin) { + this._message = _message; + this._target = _target; + this._origin = _origin; + } + Object.defineProperty(CrossFramePreparedMessage.prototype, "messageGuid", { + get: function () { return this._message.msgGuid; }, + enumerable: true, + configurable: true + }); + CrossFramePreparedMessage.prototype.send = function () { + this._target.postMessage(this._message, this._origin); + return this; + }; + return CrossFramePreparedMessage; + }()); + exports.CrossFramePreparedMessage = CrossFramePreparedMessage; + + +/***/ }, +/* 63 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Enum defining the 4 different types of messages we have defined + */ + var MessageType; + (function (MessageType) { + MessageType["Initialize"] = "initialize"; + MessageType["Notification"] = "notification"; + MessageType["Command"] = "command"; + MessageType["CommandResponse"] = "command-response"; + })(MessageType = exports.MessageType || (exports.MessageType = {})); + + +/***/ }, +/* 64 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var guid_1 = __webpack_require__(61); + var MessageTypes_1 = __webpack_require__(63); + /* tslint:disable no-any */ + function isMessage(data) { + if (!data) { + return false; + } + var message = data; + if (!message || !message.msgGuid || !message.msgType) { + return false; + } + if (!guid_1.Guid.isGuid(message.msgGuid)) { + return false; + } + if (typeof message.msgType !== 'string') { + return false; + } + var messageTypes = [MessageTypes_1.MessageType.Command, MessageTypes_1.MessageType.CommandResponse, MessageTypes_1.MessageType.Initialize, MessageTypes_1.MessageType.Notification]; + if (messageTypes.indexOf(message.msgType) < 0) { + return false; + } + return true; + } + exports.isMessage = isMessage; + function isVersion(versionNumber) { + if (!versionNumber) { + return false; + } + var v = versionNumber; + if (typeof v !== 'object') { + return false; + } + if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') { + return false; + } + return true; + } + exports.isVersion = isVersion; + function isInitMessage(message) { + if (!isMessage(message)) { + return false; + } + var initMessage = message; + if (initMessage.msgType !== MessageTypes_1.MessageType.Initialize) { + return false; + } + if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) { + return false; + } + if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) { + return false; + } + return true; + } + exports.isInitMessage = isInitMessage; + function isCommandResponseMessage(message) { + if (!isMessage(message)) { + return false; + } + var crMessage = message; + if (crMessage.msgType !== MessageTypes_1.MessageType.CommandResponse) { + return false; + } + if (!guid_1.Guid.isGuid(crMessage.commandGuid)) { + return false; + } + if (!crMessage.data && !crMessage.error) { + return false; + } + return true; + } + exports.isCommandResponseMessage = isCommandResponseMessage; + function isCommandMessage(message) { + if (!isMessage(message)) { + return false; + } + var commandMessage = message; + if (commandMessage.msgType !== MessageTypes_1.MessageType.Command) { + return false; + } + if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') { + return false; + } + if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') { + return false; + } + return true; + } + exports.isCommandMessage = isCommandMessage; + function isNotificationMessage(message) { + if (!isMessage(message)) { + return false; + } + var notificationMessage = message; + if (notificationMessage.msgType !== MessageTypes_1.MessageType.Notification) { + return false; + } + if (!notificationMessage.data || typeof notificationMessage.data !== 'object') { + return false; + } + if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') { + return false; + } + return true; + } + exports.isNotificationMessage = isNotificationMessage; + + +/***/ }, +/* 65 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * This is an implementation of the InternalApiDispatcher interface which functions by passing messages + * across a frame boundary. This is usually between the code where our javscript library has been included + * by a 3rd party dev and another frame where Tableau server has content. + */ + var CrossFrameDispatcher = (function () { + /** + * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate + * @param _messenger an instantiated and listening messenger object + */ + function CrossFrameDispatcher(_messenger) { + this._messenger = _messenger; + // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame, + // these promises can be either resolved or rejected + this._pendingPromises = {}; + // The collection of notification handlers which have been registered with this dispatcher + this._notificationHandlers = []; + if (!this._messenger) { + throw 'Missing messenger object'; + } + // Set up our message handlers. We only care about incoming notifications and command responses + this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this)); + this._messenger.setNotificationMessageHandler(this.onNotification.bind(this)); + } + ////// Start InternalApiDispatcher implementation + CrossFrameDispatcher.prototype.setVersionNumber = function (versionNumber) { + this._versionNumber = versionNumber; + }; + CrossFrameDispatcher.prototype.execute = function (verb, parameters) { + var _this = this; + // To execute a verb, we first prepare a command message and then define a promise. + var preparedMessage = this._messenger.prepareCommandMessage(verb, parameters); + var promise = new Promise(function (resolve, reject) { + // Save off the pending promise by the messageGuid we are about to send. When a response is + // received, we'll be able to resolve this promise with the result + _this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject }; + }); + // Actually send the message and return the promise + preparedMessage.send(); + return promise; + }; + CrossFrameDispatcher.prototype.registerNotificationHandler = function (handler) { + this._notificationHandlers.push(handler); + }; + CrossFrameDispatcher.prototype.unregisterNotificationHandler = function (handler) { + this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; }); + }; + ////// End InternalApiDispatcher implementation + CrossFrameDispatcher.prototype.onCommandResponse = function (response) { + // We got a command response, look through the pending promises and resolve + if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) { + return; // We don't have any reference to this command, just return + } + var pendingPromise = this._pendingPromises[response.commandGuid]; + // If we have an error defined, reject the promise + if (response.error) { + pendingPromise.reject(response.error); + } + // If we have data defined, resolve the promise + if (response.data) { + pendingPromise.resolve({ result: response.data }); + } + // Clean up our pending promises object + delete this._pendingPromises[response.commandGuid]; + }; + CrossFrameDispatcher.prototype.onNotification = function (notificationMessage) { + // Go through each notification handler we have registered and let them know a notification came in + for (var _i = 0, _a = this._notificationHandlers; _i < _a.length; _i++) { + var handler = _a[_i]; + try { + handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data }); + } + catch (e) { + // Ignore this. Wrap in try/catch so if one handler errors, the other still get the message + } + } + }; + return CrossFrameDispatcher; + }()); + exports.CrossFrameDispatcher = CrossFrameDispatcher; + + +/***/ }, +/* 66 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + var EnumConverter_1 = __webpack_require__(14); + exports.EnumConverter = EnumConverter_1.EnumConverter; + var Param_1 = __webpack_require__(16); + exports.Param = Param_1.Param; + var TableauException_1 = __webpack_require__(15); + exports.TableauException = TableauException_1.TableauException; + + +/***/ }, +/* 67 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the external DashboardContent namespace. + * This does not follow the Impl pattern as DashboardContent is + * currently just a (single) property bag. + */ + var DashboardContent = (function () { + function DashboardContent(_dashboard) { + this._dashboard = _dashboard; + } + Object.defineProperty(DashboardContent.prototype, "dashboard", { + get: function () { + return this._dashboard; + }, + enumerable: true, + configurable: true + }); + return DashboardContent; + }()); + exports.DashboardContent = DashboardContent; + + +/***/ }, +/* 68 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_shared_1 = __webpack_require__(9); + /** + * Implementation of the external environment namespace. + * Environment does not follow the Impl pattern as it is + * just a property bag. + */ + var Environment = (function () { + function Environment(extensionEnvironment) { + this._apiVersion = extensionEnvironment.apiVersion; + this._context = api_shared_1.InternalToExternalEnumMappings.extensionContext.convert(extensionEnvironment.extensionContext); + this._language = extensionEnvironment.extensionLanguage; + this._locale = extensionEnvironment.extensionLocale; + this._mode = api_shared_1.InternalToExternalEnumMappings.extensionMode.convert(extensionEnvironment.extensionMode); + this._operatingSystem = extensionEnvironment.operatingSystem; + this._tableauVersion = extensionEnvironment.tableauVersion; + } + Object.defineProperty(Environment.prototype, "apiVersion", { + get: function () { + return this._apiVersion; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "context", { + get: function () { + return this._context; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "language", { + get: function () { + return this._language; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "locale", { + get: function () { + return this._locale; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "mode", { + get: function () { + return this._mode; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "operatingSystem", { + get: function () { + return this._operatingSystem; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "tableauVersion", { + get: function () { + return this._tableauVersion; + }, + enumerable: true, + configurable: true + }); + return Environment; + }()); + exports.Environment = Environment; + + +/***/ }, +/* 69 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the external settings namespace. + */ + var Settings = (function () { + function Settings(settingsImpl) { + this.settingsImpl = settingsImpl; + } + Settings.prototype.erase = function (key) { + this.settingsImpl.erase(key); + }; + Settings.prototype.get = function (key) { + return this.settingsImpl.get(key); + }; + Settings.prototype.getAll = function () { + return this.settingsImpl.getAll(); + }; + Object.defineProperty(Settings.prototype, "isModified", { + get: function () { + return this.settingsImpl.isModified; + }, + enumerable: true, + configurable: true + }); + Settings.prototype.saveAsync = function () { + return this.settingsImpl.saveAsync(); + }; + Settings.prototype.set = function (key, value) { + this.settingsImpl.set(key, value); + }; + return Settings; + }()); + exports.Settings = Settings; + + +/***/ }, +/* 70 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_shared_1 = __webpack_require__(9); + var InitializationServiceImpl_1 = __webpack_require__(71); + var SettingsServiceImpl_1 = __webpack_require__(72); + function registerAllExtensionsServices(dispatcher) { + api_shared_1.ApiServiceRegistry.instance.registerService(new InitializationServiceImpl_1.InitializationServiceImpl(dispatcher)); + api_shared_1.ApiServiceRegistry.instance.registerService(new SettingsServiceImpl_1.SettingsServiceImpl(dispatcher)); + } + exports.registerAllExtensionsServices = registerAllExtensionsServices; + + +/***/ }, +/* 71 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(3); + var InitializationServiceImpl = (function () { + function InitializationServiceImpl(dispatcher) { + this.dispatcher = dispatcher; + } + Object.defineProperty(InitializationServiceImpl.prototype, "serviceName", { + get: function () { + return "InitializationService" /* InitializationService */; + }, + enumerable: true, + configurable: true + }); + InitializationServiceImpl.prototype.initializeDashboardExtensionsAsync = function () { + // We don't need any parameters for this call because they are added in for us by the dispatcher + return this.dispatcher.execute(api_internal_contract_1.VerbId.InitializeExtension, {}).then(function (response) { + // TODO - Validate return value + var result = response.result; + return result; + }); + }; + return InitializationServiceImpl; + }()); + exports.InitializationServiceImpl = InitializationServiceImpl; + + +/***/ }, +/* 72 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(3); + var api_utils_1 = __webpack_require__(66); + var SettingsServiceImpl = (function () { + function SettingsServiceImpl(dispatcher) { + this.dispatcher = dispatcher; + } + Object.defineProperty(SettingsServiceImpl.prototype, "serviceName", { + get: function () { + return "SettingsService" /* SettingsService */; + }, + enumerable: true, + configurable: true + }); + SettingsServiceImpl.prototype.saveSettingsAsync = function (settings) { + var parameters = (_a = {}, _a[api_internal_contract_1.ParameterId.SettingsValues] = settings, _a); + return this.dispatcher.execute(api_internal_contract_1.VerbId.SaveExtensionSettings, parameters).then(function (value) { + var result = value.result; + if (!result || !result.settingsValues) { + throw api_utils_1.TableauException.internalError(['saving settings.']); + } + return (result.settingsValues); + }); + var _a; + }; + return SettingsServiceImpl; + }()); + exports.SettingsServiceImpl = SettingsServiceImpl; + + +/***/ }, +/* 73 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_shared_1 = __webpack_require__(9); + var api_utils_1 = __webpack_require__(66); + var SettingsImpl = (function () { + function SettingsImpl(settingsInfo) { + // Since promises can't be introspected for state, keep a variable that + // indicates a save is in progress, so that set/erase can't be called during a save. + this._saveInProgress = false; + this.initializeSettings(settingsInfo); + } + SettingsImpl.prototype.erase = function (key) { + api_utils_1.Param.verifyValue(key, 'key'); + // Only make a modification if we have the key already + if (this._currentSettings[key]) { + this.verifySettingsAreUnlocked(); + delete this._currentSettings[key]; + this._isModified = true; + } + }; + SettingsImpl.prototype.get = function (key) { + api_utils_1.Param.verifyValue(key, 'key'); + return this._currentSettings[key]; + }; + SettingsImpl.prototype.getAll = function () { + // Returns a mutable copy of the settings + return Object.assign({}, this._currentSettings); + }; + Object.defineProperty(SettingsImpl.prototype, "isModified", { + get: function () { + return this._isModified; + }, + enumerable: true, + configurable: true + }); + SettingsImpl.prototype.saveAsync = function () { + var _this = this; + this.verifySettingsAreUnlocked(); + // Just resolve immediately if settings are unchanged + if (!this._isModified) { + return Promise.resolve(this._currentSettings); + } + this._saveInProgress = true; + // Use the settings service to save settings to twb + var settingsService = api_shared_1.ApiServiceRegistry.instance.getService("SettingsService" /* SettingsService */); + return settingsService.saveSettingsAsync(this._currentSettings).then(function (newSettings) { + _this._saveInProgress = false; + _this._isModified = false; + Object.assign(_this._currentSettings, newSettings); + return newSettings; + }); + }; + SettingsImpl.prototype.set = function (key, value) { + api_utils_1.Param.verifyValue(key, 'key'); // Key shouldn't be an empty string. + api_utils_1.Param.verifyString(value, 'value'); // Empty string value is allowed. + this.verifySettingsAreUnlocked(); + this._currentSettings[key] = value; + this._isModified = true; + }; + SettingsImpl.prototype.initializeSettings = function (settingsInfo) { + api_utils_1.Param.verifyValue(settingsInfo, 'settingsInfo'); + api_utils_1.Param.verifyValue(settingsInfo.settingsValues, 'settingsInfo.SettingsValues'); + this._currentSettings = settingsInfo.settingsValues; + // Reset the isModified flag + this._isModified = false; + }; + /** + * This helper should be called before any local update to this.currentSettings. + * Checks if a current save call is still in progress and throws an error if so. + */ + SettingsImpl.prototype.verifySettingsAreUnlocked = function () { + if (this._saveInProgress) { + throw api_utils_1.TableauException.error(SettingsImpl.ASYNC_SAVE_IN_PROGRESS); + } + }; + SettingsImpl.ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.'; + return SettingsImpl; + }()); + exports.SettingsImpl = SettingsImpl; + + +/***/ }, +/* 74 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the external Extensions namespace. + */ + var Extensions = (function () { + function Extensions(extensionImpl) { + this.extensionImpl = extensionImpl; + this.extensionImpl = extensionImpl; + } + Object.defineProperty(Extensions.prototype, "dashboardContent", { + get: function () { + return this.extensionImpl.dashboardContent; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "environment", { + get: function () { + return this.extensionImpl.environment; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "settings", { + get: function () { + return this.extensionImpl.settings; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "ui", { + get: function () { + throw new Error('API call not yet implemented'); + }, + enumerable: true, + configurable: true + }); + Extensions.prototype.initializeAsync = function () { + return this.extensionImpl.initializeAsync(); + }; + return Extensions; + }()); + exports.Extensions = Extensions; + + +/***/ }, +/* 75 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(20)); + + +/***/ }, +/* 76 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_core_1 = __webpack_require__(77); + var api_internal_contract_1 = __webpack_require__(98); + var api_utils_1 = __webpack_require__(99); + var AddInApiPresLayerImpl_1 = __webpack_require__(100); + var DesktopApiDispatcher_1 = __webpack_require__(101); + var QtWebChannelImpl_1 = __webpack_require__(102); + /** + * Wrapper for all the bootstrapping logic. This code attempts to initialize the qt pres-layer + * as well as the desktop dispatcher. It then assigns it to the global desktop dispatcher to + * be picked up by the add-in external Api + */ + function doBootstrap() { + if (!QtWebChannelImpl_1.hasQt()) { + return Promise.reject('Not running in desktop with qt available'); + } + // First we need to initialize the webchannel pres-layer + var dispatcherPromise = QtWebChannelImpl_1.initializeWebChannelPresLayer().then(function (preslayer) { + var presLayerApi = new AddInApiPresLayerImpl_1.AddInApiPresLayerImpl(preslayer); + if (!presLayerApi.AddInInstanceInfo.addInLocatorPresModel) { + throw api_utils_1.TableauException.isUndefined(['AddInInstanceInfo']); + } + // Initialize the apiEventHandler and the desktopDispatcher with it + var apiEventHandler = new api_core_1.ApiEventHandler(presLayerApi, presLayerApi.AddInInstanceInfo.addInLocatorPresModel, true); + var desktopDispatcher = new DesktopApiDispatcher_1.DesktopApiDispatcher(apiEventHandler); + return desktopDispatcher; + }); + // Assign the desktop dispatcher for the other project to find it + api_internal_contract_1.InternalApiDispatcherHolder.setDesktopDispatcherPromise(dispatcherPromise); + return dispatcherPromise; + } + exports.doBootstrap = doBootstrap; + + +/***/ }, +/* 77 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(78)); + var Events_1 = __webpack_require__(87); + exports.NotificationId = Events_1.NotificationId; + + +/***/ }, +/* 78 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var api_utils_1 = __webpack_require__(80); + var Params_1 = __webpack_require__(81); + var CommandMappingRegistryFactory_1 = __webpack_require__(82); + var EventMappingRegistryFactory_1 = __webpack_require__(86); + var ParameterMappingRegistryFactory_1 = __webpack_require__(91); + /** + * Main class for the api-core project. This class is responsible for executing comamnd and marshalling notifications + * between the internal Api and the pres-layer Api. After construction, SetVersionNumber must be called in order to + * use this class + * + * @export + * @class ApiEventHandler + */ + var ApiEventHandler = (function () { + /** + * Creates an instance of ApiEventHandler. + * @param {PresentationLayer} presLayer - An implementation of the pres-layer Api to use + * @param {AddInLocatorPresModel} addInLocatorPresModel - locator for the add-in which is being referenced + * @param {runningInDesktop} boolean - true if this is ApiEventHandler is created in a Desktop context. + * @memberof ApiEventHandler + */ + function ApiEventHandler(_presLayer, _presLayerAddInLocator, _runningInDesktop) { + this._presLayer = _presLayer; + this._presLayerAddInLocator = _presLayerAddInLocator; + this._runningInDesktop = _runningInDesktop; + } + /** + * Sets the internal Api version number which the external library is expecting to use. This must be called before + * anything else in order to properly set up the translation layers. + * + * @param {VersionNumber} versionNumber + * @memberof ApiEventHandler + */ + ApiEventHandler.prototype.setVersionNumber = function (versionNumber) { + this._versionNumber = versionNumber; + // Initialize all our registries + this._commandRegistry = CommandMappingRegistryFactory_1.CommandMappingRegistryFactory.createCommandMappingRegistry(versionNumber, this._runningInDesktop); + this._apiToPresLayerRegistry = ParameterMappingRegistryFactory_1.ParameterMappingRegistryFactory.createApiToPresLayerParamRegistry(versionNumber); + this._presLayerToApiRegistry = ParameterMappingRegistryFactory_1.ParameterMappingRegistryFactory.createPresLayerToApiParamRegistry(versionNumber); + this._eventRegistry = EventMappingRegistryFactory_1.EventMappingRegistryFactory.createEventMappingRegistry(versionNumber); + // Convert our addInLocator to the Api version + this._apiExtensionLocator = this._presLayerToApiRegistry + .get(Params_1.ParameterId.AddInLocator, api_internal_contract_1.ParameterId.ExtensionLocator)(this._presLayerAddInLocator); + for (var _i = 0, _a = Object.keys(this._eventRegistry); _i < _a.length; _i++) { + var plEventId = _a[_i]; + // Register for all notifications we know about and bind the event type to the callback + this._presLayer.registerNotificationHandler(plEventId, this.onPresLayerNotification.bind(this, plEventId)); + } + }; + /** + * Sets an event handler function to be notified when Api events come in. Only a single registration is supported. + * + * @param {NotificationHandler} eventHandler + * @memberof ApiEventHandler + */ + ApiEventHandler.prototype.setEventHandler = function (eventHandler) { + this._eventHandler = eventHandler; + // TODO - Register for pres layer events + }; + /** + * Executes the requested Api command by converting the parameters, running the command against the pres-layer, + * then processing the result back into a format the Api can understand + * + * @param {VerbId} verb + * @param {ExecuteParameters} parameters + * @returns {Promise} + * @memberof ApiEventHandler + */ + ApiEventHandler.prototype.execute = function (verb, parameters) { + var _this = this; + this.assertInitialized(); + var command = this._commandRegistry.getCommand(verb); + parameters = parameters || {}; + // Augment the command with the locator if it's needed + if (command.needsAddInLocator) { + parameters[api_internal_contract_1.ParameterId.ExtensionLocator] = this._apiExtensionLocator; + } + var commandsParams = command.createParams(parameters, this._apiToPresLayerRegistry); + return this._presLayer.invokeCommand(command.namespace, command.commandId, commandsParams) + .then(function (commandResult) { + var convertedResult = command.ProcessResult(commandResult, _this._presLayerToApiRegistry); + return { + result: convertedResult + }; + }); + }; + Object.defineProperty(ApiEventHandler.prototype, "ApiExtensionLocator", { + get: function () { + return this._apiExtensionLocator; + }, + enumerable: true, + configurable: true + }); + /** + * Helper method to check that things are initialized as expected. Throws if initialization not complete + * + * @private + * @memberof ApiEventHandler + */ + ApiEventHandler.prototype.assertInitialized = function () { + if (!this._versionNumber) { + throw api_utils_1.TableauException.error(ApiEventHandler.VERSION_NOT_CONFIGURED); + } + }; + /** + * Called when a new event notification comes in from the presentation layer + * + * @param eventId The pres layer event id + * @param presModel The pres model that is included with the event + */ + ApiEventHandler.prototype.onPresLayerNotification = function (eventId, presModel) { + // First look up this eventId in our registry and convert to presModel + var eventMapping = this._eventRegistry[eventId]; + var apiModel = eventMapping.converter(presModel); + if (this._eventHandler) { + this._eventHandler(eventMapping.apiId, apiModel); + } + }; + ApiEventHandler.VERSION_NOT_CONFIGURED = 'VersionNumber not yet configured. Cannot take any actions'; + return ApiEventHandler; + }()); + exports.ApiEventHandler = ApiEventHandler; + + +/***/ }, +/* 79 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(4)); + __export(__webpack_require__(5)); + __export(__webpack_require__(6)); + __export(__webpack_require__(7)); + __export(__webpack_require__(8)); + + +/***/ }, +/* 80 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + var EnumConverter_1 = __webpack_require__(14); + exports.EnumConverter = EnumConverter_1.EnumConverter; + var Param_1 = __webpack_require__(16); + exports.Param = Param_1.Param; + var TableauException_1 = __webpack_require__(15); + exports.TableauException = TableauException_1.TableauException; + + +/***/ }, +/* 81 */ +/***/ function(module, exports) { + + "use strict"; + // ----------------------------------------------------------------------------- + // + // This file is the copyrighted property of Tableau Software and is protected + // by registered patents and other applicable U.S. and international laws and + // regulations. + // + // Unlicensed use of the contents of this file is prohibited. Please refer to + // the NOTICES.txt file for further details. + // + // ----------------------------------------------------------------------------- + // WARNING: Computer generated file. Do not hand modify. + // DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/params-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-params.data'] + Object.defineProperty(exports, "__esModule", { value: true }); + var ParameterId; + (function (ParameterId) { + // DPI_IntegerRLE, having type int[] + ParameterId["IntegerRLE"] = "intRle"; + // DPI_UnsignedIntegerRLE, having type uint[] + ParameterId["UnsignedIntegerRLE"] = "uintRle"; + // DPI_FloatRLE, having type float[] + ParameterId["FloatRLE"] = "floatRle"; + // DPI_ParameterID, having type string + ParameterId["ParameterID"] = "paramType"; + // DPI_AllowCustomDatabase, having type bool + ParameterId["AllowCustomDatabase"] = "allowCustomDatabase"; + // DPI_AllowCustomSchema, having type bool + ParameterId["AllowCustomSchema"] = "allowCustomSchema"; + // DPI_AllowCustomSQL, having type bool + ParameterId["AllowCustomSQL"] = "allowCustomSql"; + // DPI_AllowCustomSQLWithoutSchema, having type bool + ParameterId["AllowCustomSQLWithoutSchema"] = "allowCustomSqlWithoutSchema"; + // DPI_AllowPreviewData, having type bool + ParameterId["AllowPreviewData"] = "allowPreviewData"; + // DPI_AllowStoredProc, having type bool + ParameterId["AllowStoredProc"] = "allowStoredProcedure"; + // DPI_AllowUnion, having type bool + ParameterId["AllowUnion"] = "allowUnion"; + // DPI_AreVariablesVisible, having type bool + ParameterId["AreVariablesVisible"] = "areVariablesVisible"; + // DPI_AttrLegacyConnection, having type bool + ParameterId["AttrLegacyConnection"] = "widgetAttrLegacy"; + // DPI_AttrReadUncommitted, having type bool + ParameterId["AttrReadUncommitted"] = "widgetAttrReadUncommittedData"; + // DPI_AttrRequireSSL, having type bool + ParameterId["AttrRequireSSL"] = "widgetAttrRequireSsl"; + // DPI_AttrRequireEncryption, having type bool + ParameterId["AttrRequireEncryption"] = "widgetAttrRequireEncryption"; + // DPI_Bool, having type bool + ParameterId["Bool"] = "bool"; + // DPI_CanPartition, having type bool + ParameterId["CanPartition"] = "canPartition"; + // DPI_CanRecommendDataSources, having type bool + ParameterId["CanRecommendDataSources"] = "canRecommendDatasources"; + // DPI_CanRecommendTables, having type bool + ParameterId["CanRecommendTables"] = "canRecommendTables"; + // DPI_CheckPermissions, having type bool + ParameterId["CheckPermissions"] = "checkPermissions"; + // DPI_DatabaseNameOptional, having type bool + ParameterId["DatabaseNameOptional"] = "databaseNameOptional"; + // DPI_DatabaseWHOptional, having type bool + ParameterId["DatabaseWHOptional"] = "databaseWarehouseOptional"; + // DPI_DoValidation, having type bool + ParameterId["DoValidation"] = "doValidation"; + // DPI_DoneLoadingAllSheets, having type bool + ParameterId["DoneLoadingAllSheets"] = "googleSheetDoneLoading"; + // DPI_GABasicItemsEnabled, having type bool + ParameterId["GABasicItemsEnabled"] = "gaBasicItemsEnabled"; + // DPI_GADimensionMeasuresEnabled, having type bool + ParameterId["GADimensionMeasuresEnabled"] = "gaDimensionsMeasuresEnabled"; + // DPI_GAFiltersEnabled, having type bool + ParameterId["GAFiltersEnabled"] = "gaFiltersEnabled"; + // DPI_HasDatabase, having type bool + ParameterId["HasDatabase"] = "hasDatabase"; + // DPI_HasDataLoss, having type bool + ParameterId["HasDataLoss"] = "hasDataLoss"; + // DPI_HasFastMetadata, having type bool + ParameterId["HasFastMetadata"] = "hasFastMetadata"; + // DPI_HasNewlyDiscoveredSchema, having type bool + ParameterId["HasNewlyDiscoveredSchema"] = "hasNewlyDiscoveredSchema"; + // DPI_HasPermissions, having type bool + ParameterId["HasPermissions"] = "hasPermissions"; + // DPI_HasSchema, having type bool + ParameterId["HasSchema"] = "hasSchema"; + // DPI_HasSchemaCount, having type bool + ParameterId["HasSchemaCount"] = "hasSchemaCount"; + // DPI_HasTables, having type bool + ParameterId["HasTables"] = "hasTables"; + // DPI_HasUncommittedChanges, having type bool + ParameterId["HasUncommittedChanges"] = "hasUncommittedChanges"; + // DPI_HasWarehouse, having type bool + ParameterId["HasWarehouse"] = "hasWarehouse"; + // DPI_HasWarning, having type bool + ParameterId["HasWarning"] = "hasWarning"; + // DPI_IsCalculated, having type bool + ParameterId["IsCalculated"] = "isCalculated"; + // DPI_IsConnectedToDataSource, having type bool + ParameterId["IsConnectedToDataSource"] = "isConnectedDatasource"; + // DPI_IsDisabledDataConnection, having type bool + ParameterId["IsDisabledDataConnection"] = "isDisabledDataConnection"; + // DPI_IsEditable, having type bool + ParameterId["IsEditable"] = "isEditable"; + // DPI_IsEnabled, having type bool + ParameterId["IsEnabled"] = "isEnabled"; + // DPI_IsFinishedConnecting, having type bool + ParameterId["IsFinishedConnecting"] = "isFinishedConnecting"; + // DPI_IsHidden, having type bool + ParameterId["IsHidden"] = "isHidden"; + // DPI_IsMultiTable, having type bool + ParameterId["IsMultiTable"] = "isMultiTable"; + // DPI_IsNewCustomSQL, having type bool + ParameterId["IsNewCustomSQL"] = "isNewCustomSql"; + // DPI_IsNewDataSource, having type bool + ParameterId["IsNewDataSource"] = "isNewDataSrc"; + // DPI_IsPublishedFederated, having type bool + ParameterId["IsPublishedFederated"] = "isPublishedFederated"; + // DPI_IsSampled, having type bool + ParameterId["IsSampled"] = "isSampled"; + // DPI_IsSchemaMemberNewlyDiscovered, having type bool + ParameterId["IsSchemaMemberNewlyDiscovered"] = "isSchemaMemberNewlyDiscovered"; + // DPI_IsSlowFast, having type bool + ParameterId["IsSlowFast"] = "isSlowfast"; + // DPI_IsSupported, having type bool + ParameterId["IsSupported"] = "isSupported"; + // DPI_IsTableSelectionVisible, having type bool + ParameterId["IsTableSelectionVisible"] = "isTableSelectionVisible"; + // DPI_IsTableauServerDatasource, having type bool + ParameterId["IsTableauServerDatasource"] = "isTableauServerDatasource"; + // DPI_IsTableauServerDatasourceConnectable, having type bool + ParameterId["IsTableauServerDatasourceConnectable"] = "isTableauServerDatasourceConnectable"; + // DPI_IsTableauServerDatasourceDownloadable, having type bool + ParameterId["IsTableauServerDatasourceDownloadable"] = "isTableauServerDatasourceDownloadable"; + // DPI_IsVisible, having type bool + ParameterId["IsVisible"] = "isVisible"; + // DPI_NeedFlatten, having type bool + ParameterId["NeedFlatten"] = "needFlatten"; + // DPI_SSLRequiresCertificate, having type bool + ParameterId["SSLRequiresCertificate"] = "sslRequiresCertificate"; + // DPI_SchemaOptional, having type bool + ParameterId["SchemaOptional"] = "schemaOptional"; + // DPI_ServiceNameOptional, having type bool + ParameterId["ServiceNameOptional"] = "serviceNameOptional"; + // DPI_ShouldWarnForCrossSchemaJoins, having type bool + ParameterId["ShouldWarnForCrossSchemaJoins"] = "shouldWarnCrossSchemaJoins"; + // DPI_ShowBrowseButton, having type bool + ParameterId["ShowBrowseButton"] = "showBrowseButton"; + // DPI_ShowConnectionPrompt, having type bool + ParameterId["ShowConnectionPrompt"] = "showConnectionPrompt"; + // DPI_ShowDBBrowseButton, having type bool + ParameterId["ShowDBBrowseButton"] = "showDbBrowseButton"; + // DPI_ShowDBNamePrompt, having type bool + ParameterId["ShowDBNamePrompt"] = "showDbPrompt"; + // DPI_ShowDBWHNamePrompt, having type bool + ParameterId["ShowDBWHNamePrompt"] = "showDbwhPrompt"; + // DPI_ShowImportSSLCertLabel, having type bool + ParameterId["ShowImportSSLCertLabel"] = "showImportSslcertLabel"; + // DPI_ShowPortPrompt, having type bool + ParameterId["ShowPortPrompt"] = "showPortPrompt"; + // DPI_ShowSSLCheckbox, having type bool + ParameterId["ShowSSLCheckbox"] = "showSslCheckbox"; + // DPI_ShowEncryptionCheckbox, having type bool + ParameterId["ShowEncryptionCheckbox"] = "showEncryptionCheckbox"; + // DPI_ShowServerNamePrompt, having type bool + ParameterId["ShowServerNamePrompt"] = "showServerPrompt"; + // DPI_ShowServiceNamePrompt, having type bool + ParameterId["ShowServiceNamePrompt"] = "showServicePrompt"; + // DPI_ShowUncommittedDataCheckbox, having type bool + ParameterId["ShowUncommittedDataCheckbox"] = "showUncommittedDataCheckbox"; + // DPI_SupportsGenericAuth, having type bool + ParameterId["SupportsGenericAuth"] = "supportsGenericAuth"; + // DPI_TableauServerFetchAscending, having type bool + ParameterId["TableauServerFetchAscending"] = "tableauServerFetchAscending"; + // DPI_UsesRadioButton, having type bool + ParameterId["UsesRadioButton"] = "usesRadioButton"; + // DPI_BigQueryLegacySQLCheckStatus, having type bool + ParameterId["BigQueryLegacySQLCheckStatus"] = "datasourceBigqueryLegacySqlCheckStatus"; + // DPI_HasBigQueryLegacySQLCheck, having type bool + ParameterId["HasBigQueryLegacySQLCheck"] = "datasourceBigqueryLegacySqlCheck"; + // DPI_AutoFetchLimit, having type int + ParameterId["AutoFetchLimit"] = "autoFetchLimit"; + // DPI_ConnectionType, having type int + ParameterId["ConnectionType"] = "connectionType"; + // DPI_IconId, having type int + ParameterId["IconId"] = "iconId"; + // DPI_SelectedCatalogIndex, having type int + ParameterId["SelectedCatalogIndex"] = "selectedCatalogIndex"; + // DPI_SelectedCubeIndex, having type int + ParameterId["SelectedCubeIndex"] = "selectedCubeIndex"; + // DPI_SelectedGAAccountIndex, having type int + ParameterId["SelectedGAAccountIndex"] = "selectedGaAccountIndex"; + // DPI_SelectedGAMeasureSetIndex, having type int + ParameterId["SelectedGAMeasureSetIndex"] = "selectedGaMeasureSetIndex"; + // DPI_SelectedGAPropertyIndex, having type int + ParameterId["SelectedGAPropertyIndex"] = "selectedGaPropertyIndex"; + // DPI_SelectedGASegmentIndex, having type int + ParameterId["SelectedGASegmentIndex"] = "selectedGaSegmentIndex"; + // DPI_SelectedGAViewIndex, having type int + ParameterId["SelectedGAViewIndex"] = "selectedGaViewIndex"; + // DPI_SelectedGoogleSheetIndex, having type int + ParameterId["SelectedGoogleSheetIndex"] = "selectedGoogleSheetIndex"; + // DPI_SelectedOptionIndex, having type int + ParameterId["SelectedOptionIndex"] = "selectedOptionIndex"; + // DPI_SlowMetadataCount, having type int + ParameterId["SlowMetadataCount"] = "slowMetadataCount"; + // DPI_TableauServerFetchSortBy, having type int + ParameterId["TableauServerFetchSortBy"] = "tableauServerFetchSort"; + // DPI_ActualParameterOrdinal, having type uint + ParameterId["ActualParameterOrdinal"] = "actualParameterOrdinal"; + // DPI_ActualParameterType, having type uint + ParameterId["ActualParameterType"] = "actualParameterType"; + // DPI_CharSetID, having type uint + ParameterId["CharSetID"] = "charsetId"; + // DPI_DataSourceOrdinal, having type uint + ParameterId["DataSourceOrdinal"] = "datasourceOrdinal"; + // DPI_FilterCount, having type uint + ParameterId["FilterCount"] = "filterCount"; + // DPI_VariablesCount, having type uint + ParameterId["VariablesCount"] = "variablesCount"; + // DPI_ActualParameterDisplayName, having type string + ParameterId["ActualParameterDisplayName"] = "actualParameterDisplayName"; + // DPI_ActualParameterName, having type string + ParameterId["ActualParameterName"] = "actualParameterName"; + // DPI_ActualParameterValue, having type string + ParameterId["ActualParameterValue"] = "actualParameterValue"; + // DPI_AttrAPIVersion, having type string + ParameterId["AttrAPIVersion"] = "attrApiVersion"; + // DPI_AttrAuthType, having type string + ParameterId["AttrAuthType"] = "widgetAttrAuthtype"; + // DPI_AttrAuthenticator, having type string + ParameterId["AttrAuthenticator"] = "widgetAttrAuthenticator"; + // DPI_AttrConnectionData, having type string + ParameterId["AttrConnectionData"] = "attrConnectionData"; + // DPI_AttrConnectionName, having type string + ParameterId["AttrConnectionName"] = "attrConnectionName"; + // DPI_AttrConnectionType, having type string + ParameterId["AttrConnectionType"] = "widgetAttrConnectiontype"; + // DPI_AttrConnectionURL, having type string + ParameterId["AttrConnectionURL"] = "attrConnectionUrl"; + // DPI_AttrCubeSpecificationId, having type string + ParameterId["AttrCubeSpecificationId"] = "widgetAttrCubeSpecificationId"; + // DPI_AttrCubeSpecificationValue, having type string + ParameterId["AttrCubeSpecificationValue"] = "widgetAttrCubeSpecificationValue"; + // DPI_AttrDSN, having type string + ParameterId["AttrDSN"] = "widgetAttrDsn"; + // DPI_AttrDatabase, having type string + ParameterId["AttrDatabase"] = "widgetAttrDb"; + // DPI_AttrDatabaseWarehouse, having type string + ParameterId["AttrDatabaseWarehouse"] = "widgetAttrDbwh"; + // DPI_AttrDriver, having type string + ParameterId["AttrDriver"] = "widgetAttrDriver"; + // DPI_AttrFilename, having type string + ParameterId["AttrFilename"] = "widgetAttrFilename"; + // DPI_AttrHTTPPath, having type string + ParameterId["AttrHTTPPath"] = "widgetAttrHttpPath"; + // DPI_AttrIncrementalRefreshKey, having type string + ParameterId["AttrIncrementalRefreshKey"] = "attrIncrementalRefreshKey"; + // DPI_AttrKerberosHost, having type string + ParameterId["AttrKerberosHost"] = "widgetAttrKerberosHost"; + // DPI_AttrKerberosRealm, having type string + ParameterId["AttrKerberosRealm"] = "widgetAttrKerberosRealm"; + // DPI_AttrKerberosService, having type string + ParameterId["AttrKerberosService"] = "widgetAttrKerberosService"; + // DPI_AttrLastRecordToken, having type string + ParameterId["AttrLastRecordToken"] = "attrLastRecordToken"; + // DPI_AttrMDWPath, having type string + ParameterId["AttrMDWPath"] = "widgetAttrMdwPath"; + // DPI_AttrMDWUsername, having type string + ParameterId["AttrMDWUsername"] = "widgetAttrMdwUsername"; + // DPI_AttrODBCPrompt, having type string + ParameterId["AttrODBCPrompt"] = "widgetAttrOdbcPrompt"; + // DPI_AttrODBCStringExtras, having type string + ParameterId["AttrODBCStringExtras"] = "widgetAttrOdbcStringExtras"; + // DPI_AttrPort, having type string + ParameterId["AttrPort"] = "widgetAttrPort"; + // DPI_AttrSAPClient, having type string + ParameterId["AttrSAPClient"] = "widgetAttrSapClient"; + // DPI_AttrSAPLanguage, having type string + ParameterId["AttrSAPLanguage"] = "widgetAttrSapLanguage"; + // DPI_AttrEdition, having type string + ParameterId["AttrEdition"] = "widgetAttrSslEdition"; + // DPI_AttrSSODomain, having type string + ParameterId["AttrSSODomain"] = "widgetAttrSsoDomain"; + // DPI_AttrSSLCert, having type string + ParameterId["AttrSSLCert"] = "widgetAttrSslCert"; + // DPI_AttrScriptVersion, having type string + ParameterId["AttrScriptVersion"] = "attrScriptVersion"; + // DPI_AttrServer, having type string + ParameterId["AttrServer"] = "widgetAttrServer"; + // DPI_AttrService, having type string + ParameterId["AttrService"] = "widgetAttrService"; + // DPI_AttrUsername, having type string + ParameterId["AttrUsername"] = "widgetAttrUser"; + // DPI_AuthenticationPrompt, having type string + ParameterId["AuthenticationPrompt"] = "authenticationPrompt"; + // DPI_ButtonClickAction, having type string + ParameterId["ButtonClickAction"] = "buttonClickAction"; + // DPI_ButtonCaption, having type string + ParameterId["ButtonCaption"] = "buttonCaption"; + // DPI_ButtonImagePath, having type string + ParameterId["ButtonImagePath"] = "buttonImagePath"; + // DPI_ButtonImagePathKey, having type string + ParameterId["ButtonImagePathKey"] = "buttonImagePathKey"; + // DPI_Caption, having type string + ParameterId["Caption"] = "caption"; + // DPI_CatalogListPrompt, having type string + ParameterId["CatalogListPrompt"] = "catalogListPrompt"; + // DPI_CatalogName, having type string + ParameterId["CatalogName"] = "catalogName"; + // DPI_CatalogSearchTerm, having type string + ParameterId["CatalogSearchTerm"] = "catalogSearchTerm"; + // DPI_Category, having type string + ParameterId["Category"] = "itemCategory"; + // DPI_ClassName, having type string + ParameterId["ClassName"] = "classNameForCleaning"; + // DPI_CloudFileClassName, having type string + ParameterId["CloudFileClassName"] = "cloudFileClassName"; + // DPI_CloudFileStorageProvider, having type string + ParameterId["CloudFileStorageProvider"] = "cloudFileStorageProvider"; + // DPI_ConfigName, having type string + ParameterId["ConfigName"] = "connectionConfigName"; + // DPI_ConnectionCaption, having type string + ParameterId["ConnectionCaption"] = "connectionCaption"; + // DPI_ConnectionDescriptionLabel, having type string + ParameterId["ConnectionDescriptionLabel"] = "connectionDescriptionLabel"; + // DPI_ConnectionClass, having type string + ParameterId["ConnectionClass"] = "connectionClassName"; + // DPI_ConnectionName, having type string + ParameterId["ConnectionName"] = "connectionName"; + // DPI_ConnectionOptionName, having type string + ParameterId["ConnectionOptionName"] = "connectionOptionName"; + // DPI_ConnectionSpecificationTitle, having type string + ParameterId["ConnectionSpecificationTitle"] = "connectionSpecificationTitle"; + // DPI_ConnectionTypeLabel, having type string + ParameterId["ConnectionTypeLabel"] = "connectionTypeLabel"; + // DPI_ConnectionURI, having type string + ParameterId["ConnectionURI"] = "connectionUri"; + // DPI_CubeDescription, having type string + ParameterId["CubeDescription"] = "cubeDescription"; + // DPI_CubeLastUpdated, having type string + ParameterId["CubeLastUpdated"] = "cubeLastUpdated"; + // DPI_CubeListPrompt, having type string + ParameterId["CubeListPrompt"] = "cubeListPrompt"; + // DPI_CubeName, having type string + ParameterId["CubeName"] = "cubeName"; + // DPI_CubeSearchTerm, having type string + ParameterId["CubeSearchTerm"] = "cubeSearchTerm"; + // DPI_CurrentText, having type string + ParameterId["CurrentText"] = "currentText"; + // DPI_CustomSplitStringSeparator, having type string + ParameterId["CustomSplitStringSeparator"] = "customSplitStringSeparator"; + // DPI_DatasourceId, having type string + ParameterId["DatasourceId"] = "datasourceId"; + // DPI_DBNamePrompt, having type string + ParameterId["DBNamePrompt"] = "dbNamePrompt"; + // DPI_DBWHNamePrompt, having type string + ParameterId["DBWHNamePrompt"] = "dbWarehouseNamePrompt"; + // DPI_DSClass, having type string + ParameterId["DSClass"] = "dsClass"; + // DPI_DatabaseName, having type string + ParameterId["DatabaseName"] = "datasourceDatabaseName"; + // DPI_DatabaseNote, having type string + ParameterId["DatabaseNote"] = "databaseNote"; + // DPI_DragLabel, having type string + ParameterId["DragLabel"] = "dragLabel"; + // DPI_EffectiveDateRange, having type string + ParameterId["EffectiveDateRange"] = "effectiveDateRange"; + // DPI_GoogleSheetCreatedTime, having type string + ParameterId["GoogleSheetCreatedTime"] = "googleSheetCreatedTime"; + // DPI_GoogleSheetId, having type string + ParameterId["GoogleSheetId"] = "googleSheetId"; + // DPI_GoogleSheetLastModifiedTime, having type string + ParameterId["GoogleSheetLastModifiedTime"] = "googleSheetLastModifiedTime"; + // DPI_GoogleSheetLastModifyingUser, having type string + ParameterId["GoogleSheetLastModifyingUser"] = "googleSheetLastModifyingUser"; + // DPI_GoogleSheetLastViewedByUserTime, having type string + ParameterId["GoogleSheetLastViewedByUserTime"] = "googleSheetLastViewedByUserTime"; + // DPI_GoogleSheetMimeType, having type string + ParameterId["GoogleSheetMimeType"] = "googleSheetMimeType"; + // DPI_GoogleSheetName, having type string + ParameterId["GoogleSheetName"] = "googleSheetName"; + // DPI_GoogleSheetOwner, having type string + ParameterId["GoogleSheetOwner"] = "googleSheetOwner"; + // DPI_GoogleSheetThumbnailLink, having type string + ParameterId["GoogleSheetThumbnailLink"] = "googleSheetThumbnailLink"; + // DPI_GoogleSheetThumbnailId, having type string + ParameterId["GoogleSheetThumbnailId"] = "googleSheetThumbnailId"; + // DPI_GoogleSheetThumbnailLocalPath, having type string + ParameterId["GoogleSheetThumbnailLocalPath"] = "googleSheetThumbnailLocalPath"; + // DPI_GoogleSheetWebViewLink, having type string + ParameterId["GoogleSheetWebViewLink"] = "googleSheetWebViewLink"; + // DPI_GoogleSheetsListErrorMessage, having type string + ParameterId["GoogleSheetsListErrorMessage"] = "googleSheetsListErrorMessage"; + // DPI_InitialSQL, having type string + ParameterId["InitialSQL"] = "initialSql"; + // DPI_ISODate, having type string + ParameterId["ISODate"] = "isoDate"; + // DPI_ISOEndDate, having type string + ParameterId["ISOEndDate"] = "isoEndDate"; + // DPI_ISOStartDate, having type string + ParameterId["ISOStartDate"] = "isoStartDate"; + // DPI_IsolationLevel, having type string + ParameterId["IsolationLevel"] = "datasourceIsolationLevel"; + // DPI_ItemDescription, having type string + ParameterId["ItemDescription"] = "itemDescription"; + // DPI_ItemId, having type string + ParameterId["ItemId"] = "itemId"; + // DPI_KerberosHost, having type string + ParameterId["KerberosHost"] = "datasourceKerberosHost"; + // DPI_KerberosRealm, having type string + ParameterId["KerberosRealm"] = "datasourceKerberosRealm"; + // DPI_KerberosService, having type string + ParameterId["KerberosService"] = "datasourceKerberosService"; + // DPI_Name, having type string + ParameterId["Name"] = "name"; + // DPI_OptionId, having type string + ParameterId["OptionId"] = "optionId"; + // DPI_PartitioningButtonLabel, having type string + ParameterId["PartitioningButtonLabel"] = "partitioningButtonLabel"; + // DPI_PartitioningButtonTooltip, having type string + ParameterId["PartitioningButtonTooltip"] = "partitioningButtonTooltip"; + // DPI_PartitioningText, having type string + ParameterId["PartitioningText"] = "queryPartitioningText"; + // DPI_PdfStartPage, having type string + ParameterId["PdfStartPage"] = "pdfStartPage"; + // DPI_PdfEndPage, having type string + ParameterId["PdfEndPage"] = "pdfEndPage"; + // DPI_PortPrompt, having type string + ParameterId["PortPrompt"] = "portPrompt"; + // DPI_PromptText, having type string + ParameterId["PromptText"] = "promptText"; + // DPI_QueryBanding, having type string + ParameterId["QueryBanding"] = "queryBanding"; + // DPI_QueryText, having type string + ParameterId["QueryText"] = "queryText"; + // DPI_RecommendationUUID, having type string + ParameterId["RecommendationUUID"] = "recommendationUuid"; + // DPI_SQLQuery, having type string + ParameterId["SQLQuery"] = "sqlQuery"; + // DPI_SchemaComboFallbackText, having type string + ParameterId["SchemaComboFallbackText"] = "schemaComboFallbackText"; + // DPI_SchemaLabel, having type string + ParameterId["SchemaLabel"] = "schemaLabel"; + // DPI_SchemaMemberGlobalName, having type string + ParameterId["SchemaMemberGlobalName"] = "schemaMemberGlobalName"; + // DPI_SchemaName, having type string + ParameterId["SchemaName"] = "datasourceSchemaName"; + // DPI_ScriptText, having type string + ParameterId["ScriptText"] = "scriptText"; + // DPI_SecondaryWhiteList, having type string + ParameterId["SecondaryWhiteList"] = "secondaryWhiteList"; + // DPI_Server, having type string + ParameterId["Server"] = "datasourceServer"; + // DPI_ServerNamePrompt, having type string + ParameterId["ServerNamePrompt"] = "serverNamePrompt"; + // DPI_Service, having type string + ParameterId["Service"] = "datasourceService"; + // DPI_ServiceNamePrompt, having type string + ParameterId["ServiceNamePrompt"] = "servicePrompt"; + // DPI_SheetFormatting, having type string + ParameterId["SheetFormatting"] = "sheetFormatting"; + // DPI_SlowMetadataSearchTerm, having type string + ParameterId["SlowMetadataSearchTerm"] = "slowMetadataSearchTerm"; + // DPI_StandardConnectionName, having type string + ParameterId["StandardConnectionName"] = "datasourceStandardConnectionName"; + // DPI_StandardConnectionPlaceholderText, having type string + ParameterId["StandardConnectionPlaceholderText"] = "standardConnectionPlaceholderText"; + // DPI_StoredProcedureParameterTitle, having type string + ParameterId["StoredProcedureParameterTitle"] = "storedProcedureParameterTitle"; + // DPI_TableAlias, having type string + ParameterId["TableAlias"] = "tableAlias"; + // DPI_RightTableAlias, having type string + ParameterId["RightTableAlias"] = "rightTableAlias"; + // DPI_TableCaption, having type string + ParameterId["TableCaption"] = "tableCaption"; + // DPI_TableCollectionName, having type string + ParameterId["TableCollectionName"] = "tableCollectionName"; + // DPI_TablePlaceholderText, having type string + ParameterId["TablePlaceholderText"] = "tablePlaceholderText"; + // DPI_TableRanking, having type string + ParameterId["TableRanking"] = "tableRanking"; + // DPI_TableSortKey, having type string + ParameterId["TableSortKey"] = "tableSortkey"; + // DPI_TableTooltip, having type string + ParameterId["TableTooltip"] = "tableTooltip"; + // DPI_TableToReplace, having type string + ParameterId["TableToReplace"] = "tableToReplace"; + // DPI_TableWarningMessage, having type string + ParameterId["TableWarningMessage"] = "tableWarningMessage"; + // DPI_TableauServerDatasourceDescription, having type string + ParameterId["TableauServerDatasourceDescription"] = "tableauServerDatasourceDescription"; + // DPI_TableauServerDatasourceLastExtract, having type string + ParameterId["TableauServerDatasourceLastExtract"] = "tableauServerDatasourceLastExtract"; + // DPI_TableauServerDatasourceModified, having type string + ParameterId["TableauServerDatasourceModified"] = "tableauServerDatasourceModified"; + // DPI_TableauServerDatasourceOwner, having type string + ParameterId["TableauServerDatasourceOwner"] = "tableauServerDatasourceOwner"; + // DPI_TableauServerDatasourcePath, having type string + ParameterId["TableauServerDatasourcePath"] = "tableauServerDatasourcePath"; + // DPI_TableauServerFetchSearchQuery, having type string + ParameterId["TableauServerFetchSearchQuery"] = "tableauServerFetchSearchQuery"; + // DPI_TableauServerName, having type string + ParameterId["TableauServerName"] = "tableauServerName"; + // DPI_TableauServerProjectName, having type string + ParameterId["TableauServerProjectName"] = "tableauServerProjectName"; + // DPI_TableauServerUsername, having type string + ParameterId["TableauServerUsername"] = "tableauServerUsername"; + // DPI_TransportType, having type string + ParameterId["TransportType"] = "transportType"; + // DPI_WarehouseName, having type string + ParameterId["WarehouseName"] = "datasourceWarehouseName"; + // DPI_WorkgroupWorkbookName, having type string + ParameterId["WorkgroupWorkbookName"] = "workgroupWorkbookName"; + // DPI_AnalyticsItemTooltip, having type string + ParameterId["AnalyticsItemTooltip"] = "analyticsItemTooltip"; + // DPI_Description, having type string + ParameterId["Description"] = "description"; + // DPI_DSClassCaption, having type string + ParameterId["DSClassCaption"] = "dsClassCaption"; + // DPI_Formula, having type string + ParameterId["Formula"] = "formula"; + // DPI_MessageText, having type string + ParameterId["MessageText"] = "messageText"; + // DPI_Datasource, having type string + ParameterId["Datasource"] = "datasource"; + // DPI_DatasourceSource, having type string + ParameterId["DatasourceSource"] = "datasourceSource"; + // DPI_DatasourceTarget, having type string + ParameterId["DatasourceTarget"] = "datasourceTarget"; + // DPI_FirstDatasource, having type string + ParameterId["FirstDatasource"] = "firstDatasource"; + // DPI_NewDatasource, having type string + ParameterId["NewDatasource"] = "newDatasource"; + // DPI_ParametersDatasource, having type string + ParameterId["ParametersDatasource"] = "parametersDatasource"; + // DPI_PrimaryDatasource, having type string + ParameterId["PrimaryDatasource"] = "primaryDatasource"; + // DPI_ConnectionDatabases, having type string[] + ParameterId["ConnectionDatabases"] = "connectionDatabases"; + // DPI_ConnectionSchemas, having type string[] + ParameterId["ConnectionSchemas"] = "connectionSchemas"; + // DPI_ConnectionWarehouses, having type string[] + ParameterId["ConnectionWarehouses"] = "connectionWarehouses"; + // DPI_DSClasses, having type string[] + ParameterId["DSClasses"] = "dsClasses"; + // DPI_PossibleChoices, having type string[] + ParameterId["PossibleChoices"] = "possibleChoices"; + // DPI_StandardConnections, having type string[] + ParameterId["StandardConnections"] = "standardConnections"; + // DPI_Strings, having type string[] + ParameterId["Strings"] = "strings"; + // DPI_TableauServerProjectNames, having type string[] + ParameterId["TableauServerProjectNames"] = "tableauServerProjectNames"; + // DPI_TableCaptions, having type string[] + ParameterId["TableCaptions"] = "tableCaptions"; + // DPI_DataValues, having type object[] + ParameterId["DataValues"] = "dataValues"; + // DPI_QueryBandErrors, having type object[] + ParameterId["QueryBandErrors"] = "queryBandErrors"; + // DPI_QueryBandParameters, having type object[] + ParameterId["QueryBandParameters"] = "queryBandParameters"; + // DPI_InitialSQLParameters, having type object[] + ParameterId["InitialSQLParameters"] = "initialSqlParameters"; + // DPI_ConnectionAttributes, having type Dictionary(of string) + ParameterId["ConnectionAttributes"] = "connectionAttrs"; + // DPI_ConnectionProps, having type Dictionary(of string) + ParameterId["ConnectionProps"] = "connectionProps"; + // DPI_DisplayNameMap, having type Dictionary(of string) + ParameterId["DisplayNameMap"] = "displayNameMap"; + // DPI_LookupTable, having type Dictionary(of string) + ParameterId["LookupTable"] = "lookupTable"; + // DPI_OAuthAttrs, having type Dictionary(of string) + ParameterId["OAuthAttrs"] = "oauthAttrs"; + // DPI_StringMap, having type Dictionary(of string) + ParameterId["StringMap"] = "stringMap"; + // DPI_TableRankingMap, having type Dictionary(of string) + ParameterId["TableRankingMap"] = "tableRankingMap"; + // DPI_WDCAttributes, having type Dictionary(of string) + ParameterId["WDCAttributes"] = "wdcAttrs"; + // DPI_ConnectorAttributes, having type Dictionary(of string) + ParameterId["ConnectorAttributes"] = "connectorAttrs"; + // DPI_TableRelevanceParams, having type Dictionary(of string) + ParameterId["TableRelevanceParams"] = "tableRelevanceParams"; + // DPI_ActualParameterParameter, having type string + ParameterId["ActualParameterParameter"] = "actualParameterParameter"; + // DPI_DataColumnName, having type string + ParameterId["DataColumnName"] = "dataColumnName"; + // DPI_LHSDataColumnName, having type string + ParameterId["LHSDataColumnName"] = "lhsDataColumnName"; + // DPI_RHSDataColumnName, having type string + ParameterId["RHSDataColumnName"] = "rhsDataColumnName"; + // DPI_FullCubeName, having type string + ParameterId["FullCubeName"] = "fullCubeName"; + // DPI_FullVariableName, having type string + ParameterId["FullVariableName"] = "fullVariableName"; + // DPI_SemanticRole, having type string + ParameterId["SemanticRole"] = "semanticRole"; + // DPI_StoredProcedureName, having type string + ParameterId["StoredProcedureName"] = "storedProcName"; + // DPI_TableName, having type string + ParameterId["TableName"] = "tableName"; + // DPI_AddedTableNames, having type string[] + ParameterId["AddedTableNames"] = "addedTableNames"; + // DPI_CoalesceGroupFields, having type string[] + ParameterId["CoalesceGroupFields"] = "coalesceGroupFields"; + // DPI_QualifiedNames, having type string[] + ParameterId["QualifiedNames"] = "qualifiedNames"; + // DPI_JoinFieldAliases, having type string[] + ParameterId["JoinFieldAliases"] = "joinField_aliases"; + // DPI_JoinInfoFields, having type string[] + ParameterId["JoinInfoFields"] = "joinInfoFields"; + // DPI_PivotGroupFields, having type string[] + ParameterId["PivotGroupFields"] = "pivotGroupFields"; + // DPI_RemovedTableNames, having type string[] + ParameterId["RemovedTableNames"] = "removedTableNames"; + // DPI_StoredProcedures, having type string[] + ParameterId["StoredProcedures"] = "storedProcedures"; + // DPI_TableNames, having type string[] + ParameterId["TableNames"] = "tableNames"; + // DPI_ColumnName, having type string + ParameterId["ColumnName"] = "columnName"; + // DPI_FieldName, having type string + ParameterId["FieldName"] = "fn"; + // DPI_FieldNames, having type string[] + ParameterId["FieldNames"] = "fieldNames"; + // DPI_GoogleSheetThumbnailImage, having type string + ParameterId["GoogleSheetThumbnailImage"] = "googleSheetThumbnailImage"; + // DPI_AttrMDWPassword, having type string + ParameterId["AttrMDWPassword"] = "widgetAttrMdwPassword"; + // DPI_AttrPassword, having type string + ParameterId["AttrPassword"] = "widgetAttrPassword"; + // DPI_DatasourcePassword, having type string + ParameterId["DatasourcePassword"] = "datasourcePassword"; + // DPI_FederatedKeychain, having type string + ParameterId["FederatedKeychain"] = "federatedKeychain"; + // DPI_DataParameterID, having type string + ParameterId["DataParameterID"] = "dataParamType"; + // DPI_ConnectServerWidgetType, having type ConnectServerWidgetType + ParameterId["ConnectServerWidgetType"] = "connectServerWidgetType"; + // DPI_AuthenticationMode, having type Mode + ParameterId["AuthenticationMode"] = "authMode"; + // DPI_ReconnectAuthMode, having type ReconnectMode + ParameterId["ReconnectAuthMode"] = "reconnectAuthMode"; + // DPI_CurrentAuthOption, having type AuthOption + ParameterId["CurrentAuthOption"] = "currAuthOption"; + // DPI_AuthOptionList, having type AuthOption[] + ParameterId["AuthOptionList"] = "authOptions"; + // DPI_ConnectionSpecificationType, having type ConnectionSpecificationType + ParameterId["ConnectionSpecificationType"] = "connectionSpecificationType"; + // DPI_DataType, having type DataType + ParameterId["DataType"] = "dataType"; + // DPI_LHSDataType, having type DataType + ParameterId["LHSDataType"] = "lhsDataType"; + // DPI_RHSDataType, having type DataType + ParameterId["RHSDataType"] = "rhsDataType"; + // DPI_DefaultFieldRole, having type FieldRole + ParameterId["DefaultFieldRole"] = "defaultFieldRole"; + // DPI_FieldRole, having type FieldRole + ParameterId["FieldRole"] = "fieldRole"; + // DPI_DefaultFieldType, having type FieldType + ParameterId["DefaultFieldType"] = "defaultFieldType"; + // DPI_FieldType, having type FieldType + ParameterId["FieldType"] = "fieldType"; + // DPI_FieldTypeList, having type FieldType[] + ParameterId["FieldTypeList"] = "fieldTypeList"; + // DPI_FieldTypeListDetail, having type FieldType[] + ParameterId["FieldTypeListDetail"] = "fieldTypeListDetail"; + // DPI_AggType, having type AggType + ParameterId["AggType"] = "aggregation"; + // DPI_DefaultAggType, having type AggType + ParameterId["DefaultAggType"] = "defaultAggregation"; + // DPI_ForecastAgg, having type AggType + ParameterId["ForecastAgg"] = "forecastSummarizeTo"; + // DPI_ForecastAutoAgg, having type AggType + ParameterId["ForecastAutoAgg"] = "forecastAutoSummarizeTo"; + // DPI_ForecastAutoRangeUnits, having type AggType + ParameterId["ForecastAutoRangeUnits"] = "forecastAutoRangeUnits"; + // DPI_ForecastEndOfRangeUnits, having type AggType + ParameterId["ForecastEndOfRangeUnits"] = "forecastEndOfRangeUnits"; + // DPI_ForecastNextRangeUnits, having type AggType + ParameterId["ForecastNextRangeUnits"] = "forecastNextRangeUnits"; + // DPI_SourceAgg, having type AggType + ParameterId["SourceAgg"] = "sourceAggregation"; + // DPI_TargetAgg, having type AggType + ParameterId["TargetAgg"] = "targetAggregation"; + // DPI_AggregateByAggTypes, having type AggType[] + ParameterId["AggregateByAggTypes"] = "aggregateByAggTypes"; + // DPI_AggregationValues, having type AggType[] + ParameterId["AggregationValues"] = "aggregationValues"; + // DPI_SortAggValues, having type AggType[] + ParameterId["SortAggValues"] = "sortAggValues"; + // DPI_ColumnClass, having type ColumnClass + ParameterId["ColumnClass"] = "columnClass"; + // DPI_DatePeriodType, having type DatePeriodType + ParameterId["DatePeriodType"] = "datePeriodType"; + // DPI_ConnectionWidgetType, having type ConnectionWidgetType + ParameterId["ConnectionWidgetType"] = "connectionWidgetType"; + // DPI_TablePillIcon, having type TablePillIcon + ParameterId["TablePillIcon"] = "tablePillIconType"; + // DPI_EnumeratedEntityType, having type EntityType + ParameterId["EnumeratedEntityType"] = "enumeratedEntityType"; + // DPI_PickEntitySearchType, having type PickEntitySearchType + ParameterId["PickEntitySearchType"] = "entitySearchType"; + // DPI_ExpressionOp, having type Op + ParameterId["ExpressionOp"] = "expressionOp"; + // DPI_ExpressionOperatorCaption, having type ExpressionOperatorCaptionPresModel + ParameterId["ExpressionOperatorCaption"] = "expressionOperatorCaption"; + // DPI_RelationalExperessionOps, having type ExpressionOperatorCaptionPresModel[] + ParameterId["RelationalExperessionOps"] = "relationalExpressionOps"; + // DPI_HierarchyExpressionOps, having type ExpressionOperatorCaptionPresModel[] + ParameterId["HierarchyExpressionOps"] = "hierarchyExpressionOps"; + // DPI_DefaultSortDirection, having type SortDirection + ParameterId["DefaultSortDirection"] = "defSortOrder"; + // DPI_SortDirection, having type SortDirection + ParameterId["SortDirection"] = "sortOrder"; + // DPI_SortDirectionValues, having type SortDirection[] + ParameterId["SortDirectionValues"] = "sortDirectionValues"; + // DPI_CubeMetadataCategory, having type CubeMetadataCategory + ParameterId["CubeMetadataCategory"] = "cubeMetadataCategory"; + // DPI_CubeMetadataCategories, having type CubeMetadataCategory[] + ParameterId["CubeMetadataCategories"] = "cubeMetadataCategories"; + // DPI_GoogleBasicInfoType, having type GoogleBasicInfoType + ParameterId["GoogleBasicInfoType"] = "googleBasicInfoType"; + // DPI_GoogleAnalyticsDateRangeOptionType, having type DateRange + ParameterId["GoogleAnalyticsDateRangeOptionType"] = "googleAnalyticsDateRangeOptionType"; + // DPI_TableCalcType, having type TableCalcType + ParameterId["TableCalcType"] = "tableCalcType"; + // DPI_TableCalcTypeValues, having type TableCalcType[] + ParameterId["TableCalcTypeValues"] = "tableCalcTypeValues"; + // DPI_RelativeAddress, having type RelativeAddress + ParameterId["RelativeAddress"] = "relativeAddress"; + // DPI_RelativeValues, having type RelativeAddress[] + ParameterId["RelativeValues"] = "relativeValues"; + // DPI_OrderingType, having type OrderingType + ParameterId["OrderingType"] = "orderingType"; + // DPI_OrderingTypeValues, having type OrderingType[] + ParameterId["OrderingTypeValues"] = "orderingTypeValues"; + // DPI_CategoricalBinItemType, having type CategoricalBinItemType + ParameterId["CategoricalBinItemType"] = "categoricalBinItemType"; + // DPI_AuthenticationInfos, having type AuthenticationSettingsPresModel + ParameterId["AuthenticationInfos"] = "authInfo"; + // DPI_ConnectionWidgetParams, having type ConnectionParamsPresModel + ParameterId["ConnectionWidgetParams"] = "widgetConnectionParams"; + // DPI_ConnectionSettings, having type ConnectionSettingsPresModel + ParameterId["ConnectionSettings"] = "connectionSettings"; + // DPI_ReconnectAuthenticationSettings, having type AuthenticationSettingsPresModel + ParameterId["ReconnectAuthenticationSettings"] = "reconnectAuthSettings"; + // DPI_CubeConnectionSpecificationOption, having type CubeConnectionSpecificationOptionPresModel + ParameterId["CubeConnectionSpecificationOption"] = "cubeConnectionSpecificationOption"; + // DPI_CubeConnectionSpecificationOptions, having type CubeConnectionSpecificationOptionPresModel[] + ParameterId["CubeConnectionSpecificationOptions"] = "cubeConnectionSpecificationOptions"; + // DPI_CubeConnectionSpecification, having type CubeConnectionSpecificationPresModel + ParameterId["CubeConnectionSpecification"] = "cubeConnectionSpecification"; + // DPI_ConnectionSettingsOption, having type ConnectionSettingsOptionPresModel + ParameterId["ConnectionSettingsOption"] = "connectionSettingsOption"; + // DPI_ConnectionSettingsOptions, having type ConnectionSettingsOptionPresModel[] + ParameterId["ConnectionSettingsOptions"] = "connectionSettingsOptions"; + // DPI_StringCollation, having type StringCollationPresModel + ParameterId["StringCollation"] = "stringCollation"; + // DPI_DatabaseEnumeration, having type DatabaseEnumerationPresModel + ParameterId["DatabaseEnumeration"] = "databaseEnumeration"; + // DPI_SchemaEnumeration, having type SchemaEnumerationPresModel + ParameterId["SchemaEnumeration"] = "schemaEnumeration"; + // DPI_StandardConnectionEnumeration, having type StandardConnectionEnumerationPresModel + ParameterId["StandardConnectionEnumeration"] = "standardConnectionEnumeration"; + // DPI_StoredProcedureEnumeration, having type StoredProcedureEnumerationPresModel + ParameterId["StoredProcedureEnumeration"] = "storedProcedureEnumeration"; + // DPI_TableEnumeration, having type TableEnumerationPresModel + ParameterId["TableEnumeration"] = "tableEnumeration"; + // DPI_WarehouseEnumeration, having type WarehouseEnumerationPresModel + ParameterId["WarehouseEnumeration"] = "warehouseEnumeration"; + // DPI_SlowMetadataSchemaList, having type SlowMetadataSchemaListPresModel + ParameterId["SlowMetadataSchemaList"] = "slowMetadataSchemaList"; + // DPI_SlowMetadataTableList, having type SlowMetadataTableListPresModel + ParameterId["SlowMetadataTableList"] = "slowMetadataTableList"; + // DPI_CubeCatalog, having type CubeCatalogPresModel + ParameterId["CubeCatalog"] = "cubeCatalog"; + // DPI_CubeCatalogs, having type CubeCatalogPresModel[] + ParameterId["CubeCatalogs"] = "cubeCatalogs"; + // DPI_CubeCatalogEnumeration, having type CubeCatalogEnumerationPresModel + ParameterId["CubeCatalogEnumeration"] = "cubeCatalogEnumeration"; + // DPI_Cube, having type CubePresModel + ParameterId["Cube"] = "cube"; + // DPI_Cubes, having type CubePresModel[] + ParameterId["Cubes"] = "cubes"; + // DPI_CubeEnumeration, having type CubeEnumerationPresModel + ParameterId["CubeEnumeration"] = "cubeEnumeration"; + // DPI_GoogleAnalyticsBasicItem, having type GoogleAnalyticsBasicItemPresModel + ParameterId["GoogleAnalyticsBasicItem"] = "googleAnalyticsBasicItem"; + // DPI_GAMeasureSets, having type GoogleAnalyticsBasicItemPresModel[] + ParameterId["GAMeasureSets"] = "gaMeasureSets"; + // DPI_GoogleAnalyticsViews, having type GoogleAnalyticsBasicItemPresModel[] + ParameterId["GoogleAnalyticsViews"] = "googleAnalyticsViews"; + // DPI_GoogleAnalyticsProperties, having type GoogleAnalyticsBasicItemPresModel[] + ParameterId["GoogleAnalyticsProperties"] = "googleAnalyticsProperties"; + // DPI_GoogleBasicInfoItems, having type GoogleAnalyticsBasicItemPresModel[] + ParameterId["GoogleBasicInfoItems"] = "googleAnalyticsAccounts"; + // DPI_GoogleAnalyticsComplexItem, having type GoogleAnalyticsComplexItemPresModel + ParameterId["GoogleAnalyticsComplexItem"] = "googleAnalyticsComplexItem"; + // DPI_GoogleAnalyticsPossibleDimensions, having type GoogleAnalyticsComplexItemPresModel[] + ParameterId["GoogleAnalyticsPossibleDimensions"] = "googleAnalyticsPossibleDimensions"; + // DPI_GoogleAnalyticsPossibleMeasures, having type GoogleAnalyticsComplexItemPresModel[] + ParameterId["GoogleAnalyticsPossibleMeasures"] = "googleAnalyticsPossibleMeasures"; + // DPI_GoogleAnalyticsPossibleSegments, having type GoogleAnalyticsComplexItemPresModel[] + ParameterId["GoogleAnalyticsPossibleSegments"] = "googleAnalyticsPossibleSegments"; + // DPI_GoogleAnalyticsSelectedDimensions, having type GoogleAnalyticsComplexItemPresModel[] + ParameterId["GoogleAnalyticsSelectedDimensions"] = "googleAnalyticsSelectedDimensions"; + // DPI_GoogleAnalyticsSelectedMeasures, having type GoogleAnalyticsComplexItemPresModel[] + ParameterId["GoogleAnalyticsSelectedMeasures"] = "googleAnalyticsSelectedMeasures"; + // DPI_GoogleAnalyticsDateRangeOption, having type GoogleAnalyticsDateRangeOptionPresModel + ParameterId["GoogleAnalyticsDateRangeOption"] = "googleAnalyticsDateRangeOption"; + // DPI_GoogleAnalyticsDateRangeOptions, having type GoogleAnalyticsDateRangeOptionPresModel[] + ParameterId["GoogleAnalyticsDateRangeOptions"] = "googleAnalyticsDateRangeOptions"; + // DPI_GoogleAnalyticsEndDate, having type GoogleAnalyticsDatePresModel + ParameterId["GoogleAnalyticsEndDate"] = "googleAnalyticsEndDate"; + // DPI_GoogleAnalyticsStartDate, having type GoogleAnalyticsDatePresModel + ParameterId["GoogleAnalyticsStartDate"] = "googleAnalyticsStartDate"; + // DPI_GoogleAnalyticsDateRange, having type GoogleAnalyticsDateRangePresModel + ParameterId["GoogleAnalyticsDateRange"] = "googleAnalyticsDateRange"; + // DPI_GoogleAnalyticsQueryPartitioning, having type GoogleAnalyticsQueryPartitioningPresModel + ParameterId["GoogleAnalyticsQueryPartitioning"] = "googleAnalyticsQueryPartitioning"; + // DPI_GAConnectionDescription, having type GoogleAnalyticsConnectionDescriptionPresModel + ParameterId["GAConnectionDescription"] = "gaConnectionDescription"; + // DPI_GoogleSheetItem, having type GoogleSheetItemPresModel + ParameterId["GoogleSheetItem"] = "googleSheetItem"; + // DPI_GoogleSheetItems, having type GoogleSheetItemPresModel[] + ParameterId["GoogleSheetItems"] = "googleSheetItems"; + // DPI_GoogleSheetsListPresModel, having type GoogleSheetsListPresModel + ParameterId["GoogleSheetsListPresModel"] = "googleSheetsList"; + // DPI_GoogleSheetPanePresModel, having type GoogleSheetPanePresModel + ParameterId["GoogleSheetPanePresModel"] = "googleSheetPane"; + // DPI_TableauServerConnectionDescription, having type TableauServerConnectionDescriptionPresModel + ParameterId["TableauServerConnectionDescription"] = "tableauServerConnectionDescription"; + // DPI_InitialSQLPresModel, having type InitialSQLPresModel + ParameterId["InitialSQLPresModel"] = "initialSqlPresModel"; + // DPI_QueryBandingPresModel, having type QueryBandingPresModel + ParameterId["QueryBandingPresModel"] = "queryBandingPresModel"; + // DPI_SlowMetadata, having type SlowMetadataPresModel + ParameterId["SlowMetadata"] = "slowMetadata"; + // DPI_SlowMetadataSchemaSearchPresModel, having type SlowMetadataSearchPresModel + ParameterId["SlowMetadataSchemaSearchPresModel"] = "slowMetadataSchemaSearch"; + // DPI_SlowMetadataTableSearchPresModel, having type SlowMetadataSearchPresModel + ParameterId["SlowMetadataTableSearchPresModel"] = "slowMetadataTableSearch"; + // DPI_TableauServerProjectsPresModel, having type TableauServerProjectsPresModel + ParameterId["TableauServerProjectsPresModel"] = "tableauServerProjectsPresmodel"; + // DPI_TableauServerDataSourcePresModel, having type TableauServerDataSourcePresModel + ParameterId["TableauServerDataSourcePresModel"] = "tableauServerDataSourcePresmodel"; + // DPI_TableauServerDataSourcePresModels, having type TableauServerDataSourcePresModel[] + ParameterId["TableauServerDataSourcePresModels"] = "tableauServerDataSourcePresmodels"; + // DPI_TableauServerDataSourcesPresModel, having type TableauServerDataSourcesPresModel + ParameterId["TableauServerDataSourcesPresModel"] = "tableauServerDataSourcesPresmodel"; + // DPI_TableauServerDataPresModel, having type TableauServerDataPresModel + ParameterId["TableauServerDataPresModel"] = "tableauServerDataPresmodel"; + // DPI_StoredProcedureParameterPresModel, having type StoredProcedureParameterPresModel + ParameterId["StoredProcedureParameterPresModel"] = "storedProcedureParameter"; + // DPI_StoredProcedureParametersPresModel, having type StoredProcedureParameterPresModel[] + ParameterId["StoredProcedureParametersPresModel"] = "storedProcedureParameters"; + // DPI_CustomSQLInfo, having type CustomSQLInfoPresModel + ParameterId["CustomSQLInfo"] = "customSqlInfo"; + // DPI_ConnectionTableInfo, having type ConnectionTableInfoPresModel + ParameterId["ConnectionTableInfo"] = "connectionTableInfo"; + // DPI_TableInfos, having type ConnectionTableInfoPresModel[] + ParameterId["TableInfos"] = "tableInfos"; + // DPI_ConnectionDescription, having type ConnectionDescriptionPresModel + ParameterId["ConnectionDescription"] = "connectionDescription"; + // DPI_ConnectionDescriptionSummary, having type ConnectionDescriptionSummaryPresModel + ParameterId["ConnectionDescriptionSummary"] = "connectionDescriptionSummary"; + // DPI_ConnectionDescriptionSummaries, having type ConnectionDescriptionSummaryPresModel[] + ParameterId["ConnectionDescriptionSummaries"] = "connectionDescriptionSummaries"; + // DPI_DataSourceParserValidationMode, having type DataSourceParserValidationMode + ParameterId["DataSourceParserValidationMode"] = "dataSourceParserValidationMode"; + // DPI_OAuthCredentialTypeInfo, having type OAuthCredentialTypeInfoPresModel + ParameterId["OAuthCredentialTypeInfo"] = "oauthCredentialTypeInfo"; + // DPI_OAuthCredentialTypeInfos, having type OAuthCredentialTypeInfoPresModel[] + ParameterId["OAuthCredentialTypeInfos"] = "oauthCredentialTypeInfos"; + // DPI_OAuthSettings, having type OAuthSettingsPresModel + ParameterId["OAuthSettings"] = "oauthSettings"; + // DPI_CredentialTypePropertiesFlag, having type CredentialTypePropertiesFlag + ParameterId["CredentialTypePropertiesFlag"] = "credentialTypePropertiesFlag"; + // DPI_CredentialTypePropertiesFlags, having type CredentialTypePropertiesFlag[] + ParameterId["CredentialTypePropertiesFlags"] = "credentialTypePropertiesFlags"; + // DPI_ConnectionTypeEnum, having type ConnectionTypeEnum + ParameterId["ConnectionTypeEnum"] = "connectionTypeEnum"; + // DPI_ConnectorType, having type ConnectorType + ParameterId["ConnectorType"] = "connectorType"; + // DPI_PdfPagePicker, having type PdfPagePickerPresModel + ParameterId["PdfPagePicker"] = "pdfPagePicker"; + // DPI_ActivateNew, having type bool + ParameterId["ActivateNew"] = "activateNew"; + // DPI_AddActions, having type bool + ParameterId["AddActions"] = "addActions"; + // DPI_AddAsFloating, having type bool + ParameterId["AddAsFloating"] = "addAsFloating"; + // DPI_AddColorDictionary, having type bool + ParameterId["AddColorDictionary"] = "addColorDictionary"; + // DPI_AddDroplines, having type bool + ParameterId["AddDroplines"] = "addDroplines"; + // DPI_AddHeaders, having type bool + ParameterId["AddHeaders"] = "addHeaders"; + // DPI_AddHighlighting, having type bool + ParameterId["AddHighlighting"] = "addHighlighting"; + // DPI_AddImageDictionary, having type bool + ParameterId["AddImageDictionary"] = "addImageDictionary"; + // DPI_AddMarkLabels, having type bool + ParameterId["AddMarkLabels"] = "addMarkLabels"; + // DPI_AddPages, having type bool + ParameterId["AddPages"] = "addPages"; + // DPI_AddSelection, having type bool + ParameterId["AddSelection"] = "addSelection"; + // DPI_AddToFolder, having type bool + ParameterId["AddToFolder"] = "addToFolder"; + // DPI_AddVizData, having type bool + ParameterId["AddVizData"] = "addVizData"; + // DPI_AlertConditionMet, having type bool + ParameterId["AlertConditionMet"] = "alertConditionMet"; + // DPI_AllFields, having type bool + ParameterId["AllFields"] = "allFields"; + // DPI_AllOnEmpty, having type bool + ParameterId["AllOnEmpty"] = "allOnEmpty"; + // DPI_AllPages, having type bool + ParameterId["AllPages"] = "includeAllPages"; + // DPI_AllowPreviewSizeChange, having type bool + ParameterId["AllowPreviewSizeChange"] = "allowPreviewSizeChange"; + // DPI_AllSelectedIsEffectivelyRangeTypeAll, having type bool + ParameterId["AllSelectedIsEffectivelyRangeTypeAll"] = "allSelectedIsEffectivelyRangeTypeAll"; + // DPI_AllStoryPoints, having type bool + ParameterId["AllStoryPoints"] = "allStorypoints"; + // DPI_AllowAllRange, having type bool + ParameterId["AllowAllRange"] = "allowAllRange"; + // DPI_AllowCreatingNewParameters, having type bool + ParameterId["AllowCreatingNewParameters"] = "allowCreatingNewParameters"; + // DPI_AllowContinuousDate, having type bool + ParameterId["AllowContinuousDate"] = "allowContinuousDate"; + // DPI_AllowDuplicateFieldDropOnFilterShelf, having type bool + ParameterId["AllowDuplicateFieldDropOnFilterShelf"] = "allowDuplicateFieldDropOnFilterShelf"; + // DPI_AllowFilterPreset, having type bool + ParameterId["AllowFilterPreset"] = "allowFilterPreset"; + // DPI_AllowHoverActions, having type bool + ParameterId["AllowHoverActions"] = "allowHoverActions"; + // DPI_AllowHyphenation, having type bool + ParameterId["AllowHyphenation"] = "allowHyphenation"; + // DPI_AllowJoinOnCalc, having type bool + ParameterId["AllowJoinOnCalc"] = "allowJoinOnCalc"; + // DPI_AllowManualRange, having type bool + ParameterId["AllowManualRange"] = "allowManualRange"; + // DPI_AllowMapping, having type bool + ParameterId["AllowMapping"] = "allowMapping"; + // DPI_AllowMultiSelect, having type bool + ParameterId["AllowMultiSelect"] = "allowMultiSelect"; + // DPI_AllowNull, having type bool + ParameterId["AllowNull"] = "allowNull"; + // DPI_AllowPanZoom, having type bool + ParameterId["AllowPanZoom"] = "allowPanZoom"; + // DPI_AllowPatternBased, having type bool + ParameterId["AllowPatternBased"] = "allowPatternBasedUnion"; + // DPI_AllowPromptText, having type bool + ParameterId["AllowPromptText"] = "allowPromptText"; + // DPI_AllowSaveDataSource, having type bool + ParameterId["AllowSaveDataSource"] = "allowSaveDataSource"; + // DPI_AllowWholeDate, having type bool + ParameterId["AllowWholeDate"] = "allowWholeDate"; + // DPI_AllowWork, having type bool + ParameterId["AllowWork"] = "allowWork"; + // DPI_AllowWrap, having type bool + ParameterId["AllowWrap"] = "allowWrap"; + // DPI_AppIs32Bit, having type bool + ParameterId["AppIs32Bit"] = "appIs32Bit"; + // DPI_AppIs64Bit, having type bool + ParameterId["AppIs64Bit"] = "appIs64Bit"; + // DPI_AppIsBeta, having type bool + ParameterId["AppIsBeta"] = "appIsBeta"; + // DPI_AppIsOEM, having type bool + ParameterId["AppIsOEM"] = "appIsOem"; + // DPI_AppendTde, having type bool + ParameterId["AppendTde"] = "appendTde"; + // DPI_ApplyColors, having type bool + ParameterId["ApplyColors"] = "applyColors"; + // DPI_ApplyNewSelection, having type bool + ParameterId["ApplyNewSelection"] = "applyNewSelection"; + // DPI_AreConfidenceBandsValid, having type bool + ParameterId["AreConfidenceBandsValid"] = "areConfidenceBandsValid"; + // DPI_AreDataSourceFiltersVisible, having type bool + ParameterId["AreDataSourceFiltersVisible"] = "areDataSourceFiltersVisible"; + // DPI_AreExtractFiltersEnabled, having type bool + ParameterId["AreExtractFiltersEnabled"] = "areExtractFiltersEnabled"; + // DPI_AreTotalsUsed, having type bool + ParameterId["AreTotalsUsed"] = "areTotalsUsed"; + // DPI_AtTheLevelFieldIsInvalid, having type bool + ParameterId["AtTheLevelFieldIsInvalid"] = "atTheLevelFieldIsInvalid"; + // DPI_AutoURL, having type bool + ParameterId["AutoURL"] = "autoUrl"; + // DPI_AutoUpdate, having type bool + ParameterId["AutoUpdate"] = "autoUpdate"; + // DPI_BackingSheetIsDashboard, having type bool + ParameterId["BackingSheetIsDashboard"] = "isBackingSheetDashboard"; + // DPI_BeginDataSourcePresModelUpdate, having type bool + ParameterId["BeginDataSourcePresModelUpdate"] = "beginDataSourcePresModelUpdate"; + // DPI_AggregateDrillUp, having type bool + ParameterId["AggregateDrillUp"] = "boolAggregateDrillUp"; + // DPI_BoxplotMarkExclusion, having type bool + ParameterId["BoxplotMarkExclusion"] = "boxplotMarkExclusion"; + // DPI_BreakPageOnPane, having type bool + ParameterId["BreakPageOnPane"] = "breakPageOnPane"; + // DPI_BrushLegends, having type bool + ParameterId["BrushLegends"] = "brushLegends"; + // DPI_CachePresModels, having type bool + ParameterId["CachePresModels"] = "cachePresModels"; + // DPI_CanAddConnections, having type bool + ParameterId["CanAddConnections"] = "canAddConnections"; + // DPI_SortPillCanBeDragged, having type bool + ParameterId["SortPillCanBeDragged"] = "sortPillCanBeDragged"; + // DPI_CanAddTable, having type bool + ParameterId["CanAddTable"] = "canAddTable"; + // DPI_CanAddToDrillPath, having type bool + ParameterId["CanAddToDrillPath"] = "canAddToDrillPath"; + // DPI_CanAnalyzeData, having type bool + ParameterId["CanAnalyzeData"] = "canAnalyzeData"; + // DPI_CanChangeDataType, having type bool + ParameterId["CanChangeDataType"] = "canChangeDataType"; + // DPI_CanChangeSemanticRole, having type bool + ParameterId["CanChangeSemanticRole"] = "canChangeSemanticRole"; + // DPI_CanDerive, having type bool + ParameterId["CanDerive"] = "canDerive"; + // DPI_CanDrop, having type bool + ParameterId["CanDrop"] = "canDrop"; + // DPI_CanEdit, having type bool + ParameterId["CanEdit"] = "canEdit"; + // DPI_CanEditLegendColor, having type bool + ParameterId["CanEditLegendColor"] = "canEditLegendColor"; + // DPI_CanEnableCenter, having type bool + ParameterId["CanEnableCenter"] = "canEnableCenter"; + // DPI_CanShowAdvancedSettings, having type bool + ParameterId["CanShowAdvancedSettings"] = "canShowAdvancedSettings"; + // DPI_CanEnableFilterStateButton, having type bool + ParameterId["CanEnableFilterStateButton"] = "canEnableFilterStateButton"; + // DPI_CanFloat, having type bool + ParameterId["CanFloat"] = "canFloat"; + // DPI_CanHaveTitle, having type bool + ParameterId["CanHaveTitle"] = "canHaveTitle"; + // DPI_CanIgnoreUpdate, having type bool + ParameterId["CanIgnoreUpdate"] = "canIgnoreUpdate"; + // DPI_CanLogTransformExplanatoryAxis, having type bool + ParameterId["CanLogTransformExplanatoryAxis"] = "canLogTransformExplanatoryAxis"; + // DPI_CanNavigateBack, having type bool + ParameterId["CanNavigateBack"] = "canNavigateBack"; + // DPI_CanNavigateForward, having type bool + ParameterId["CanNavigateForward"] = "canNavigateForward"; + // DPI_CanScrollX, having type bool + ParameterId["CanScrollX"] = "canScrollX"; + // DPI_CanScrollY, having type bool + ParameterId["CanScrollY"] = "canScrollY"; + // DPI_CanSetDomain, having type bool + ParameterId["CanSetDomain"] = "canSetDomain"; + // DPI_CanSetMapUnit, having type bool + ParameterId["CanSetMapUnit"] = "canSetMapUnit"; + // DPI_CanShowApplyButton, having type bool + ParameterId["CanShowApplyButton"] = "canShowApplyButton"; + // DPI_CanShowFilterStateButton, having type bool + ParameterId["CanShowFilterStateButton"] = "canShowFilterStateButton"; + // DPI_CanShowMoreFewerButton, having type bool + ParameterId["CanShowMoreFewerButton"] = "canShowMoreFewerButton"; + // DPI_CanShowSyncClientOptions, having type bool + ParameterId["CanShowSyncClientOptions"] = "canShowSyncClientOptions"; + // DPI_CanSort, having type bool + ParameterId["CanSort"] = "canSort"; + // DPI_CanSortOrdinally, having type bool + ParameterId["CanSortOrdinally"] = "canSortOrdinal"; + // DPI_CanToggleAutomaticDrill, having type bool + ParameterId["CanToggleAutomaticDrill"] = "canToggleAutomaticDrill"; + // DPI_CanToggleGeographicSearch, having type bool + ParameterId["CanToggleGeographicSearch"] = "canToggleGeographicSearch"; + // DPI_CanToggleMapScale, having type bool + ParameterId["CanToggleMapScale"] = "canToggleMapScale"; + // DPI_CanUseFullColorRange, having type bool + ParameterId["CanUseFullColorRange"] = "canUseFullColorRange"; + // DPI_CanUseMultipleHierarchies, having type bool + ParameterId["CanUseMultipleHierarchies"] = "canUseMultipleHierarchies"; + // DPI_CenterHorizontally, having type bool + ParameterId["CenterHorizontally"] = "centerHorizontally"; + // DPI_CenterVertically, having type bool + ParameterId["CenterVertically"] = "centerVertically"; + // DPI_ChangeAllFields, having type bool + ParameterId["ChangeAllFields"] = "changeAllFields"; + // DPI_Changed, having type bool + ParameterId["Changed"] = "changed"; + // DPI_ClearBrushing, having type bool + ParameterId["ClearBrushing"] = "clearBrushing"; + // DPI_ClearSort, having type bool + ParameterId["ClearSort"] = "clearSort"; + // DPI_ClearView, having type bool + ParameterId["ClearView"] = "clearView"; + // DPI_Collapsed, having type bool + ParameterId["Collapsed"] = "collapsed"; + // DPI_ConsolidateInCommit, having type bool + ParameterId["ConsolidateInCommit"] = "consolidateInCommit"; + // DPI_ClusterEnableScaledCheckbox, having type bool + ParameterId["ClusterEnableScaledCheckbox"] = "clusterEnableScaledCheckbox"; + // DPI_CommitPillFinished, having type bool + ParameterId["CommitPillFinished"] = "commitPillFinished"; + // DPI_CompressArrays, having type bool + ParameterId["CompressArrays"] = "compressArrays"; + // DPI_ComputeCompoundedRate, having type bool + ParameterId["ComputeCompoundedRate"] = "computeCompoundedRate"; + // DPI_ConfidenceIntervalAllowed, having type bool + ParameterId["ConfidenceIntervalAllowed"] = "confidenceIntervalAllowed"; + // DPI_ConfigIsDesktopStandard, having type bool + ParameterId["ConfigIsDesktopStandard"] = "configIsDesktopStandard"; + // DPI_ConfigIsInteractor, having type bool + ParameterId["ConfigIsInteractor"] = "configIsInteractor"; + // DPI_ConfigIsPublic, having type bool + ParameterId["ConfigIsPublic"] = "configIsPublic"; + // DPI_ConfigIsReader, having type bool + ParameterId["ConfigIsReader"] = "configIsReader"; + // DPI_ContainsQuant, having type bool + ParameterId["ContainsQuant"] = "containsQuant"; + // DPI_ContainsValidDatasources, having type bool + ParameterId["ContainsValidDatasources"] = "containsValidDatasources"; + // DPI_ControllerMissing, having type bool + ParameterId["ControllerMissing"] = "controllerMissing"; + // DPI_CreateExtractForPublish, having type bool + ParameterId["CreateExtractForPublish"] = "createExtractForPublish"; + // DPI_CrossTab, having type bool + ParameterId["CrossTab"] = "crossTab"; + // DPI_CullLabels, having type bool + ParameterId["CullLabels"] = "cullLabels"; + // DPI_CurrentCustViewIdFlag, having type bool + ParameterId["CurrentCustViewIdFlag"] = "isCurrentCustViewIdValid"; + // DPI_DashboardEnableSnap, having type bool + ParameterId["DashboardEnableSnap"] = "dashboardEnableSnap"; + // DPI_DashboardShowGrid, having type bool + ParameterId["DashboardShowGrid"] = "dashboardShowGrid"; + // DPI_DataGridSortOrder, having type bool + ParameterId["DataGridSortOrder"] = "datagridSortOrder"; + // DPI_DeleteExtract, having type bool + ParameterId["DeleteExtract"] = "deleteExtract"; + // DPI_DeleteOnlySpecifiedSelection, having type bool + ParameterId["DeleteOnlySpecifiedSelection"] = "deleteOnlySpecifiedSelection"; + // DPI_DeleteOrphans, having type bool + ParameterId["DeleteOrphans"] = "deleteOrphans"; + // DPI_DimensionIsEffectivelyEmpty, having type bool + ParameterId["DimensionIsEffectivelyEmpty"] = "dimensionIsEffectivelyEmpty"; + // DPI_DisabledDataConnectionClassNames, having type bool + ParameterId["DisabledDataConnectionClassNames"] = "disabledDataConnectionClassNames"; + // DPI_DisablePresModelHandler, having type bool + ParameterId["DisablePresModelHandler"] = "disablePresModelHandler"; + // DPI_DisplayDate, having type bool + ParameterId["DisplayDate"] = "displayDate"; + // DPI_DisplayTime, having type bool + ParameterId["DisplayTime"] = "displayTime"; + // DPI_DoDropUIAction, having type bool + ParameterId["DoDropUIAction"] = "doDropUiAction"; + // DPI_DoMerge, having type bool + ParameterId["DoMerge"] = "doMerge"; + // DPI_DoPreDropUIAction, having type bool + ParameterId["DoPreDropUIAction"] = "doPreDropUiAction"; + // DPI_DoQuery, having type bool + ParameterId["DoQuery"] = "doQuery"; + // DPI_DragHorz, having type bool + ParameterId["DragHorz"] = "dragHorz"; + // DPI_DrillDown, having type bool + ParameterId["DrillDown"] = "drillDown"; + // DPI_DropToXAxis, having type bool + ParameterId["DropToXAxis"] = "dropToXAxis"; + // DPI_DropToYAxis, having type bool + ParameterId["DropToYAxis"] = "dropToYAxis"; + // DPI_DropUnnamedFields, having type bool + ParameterId["DropUnnamedFields"] = "dropUnnamedFields"; + // DPI_EditExisting, having type bool + ParameterId["EditExisting"] = "editExisting"; + // DPI_EditingConnection, having type bool + ParameterId["EditingConnection"] = "editingConnection"; + // DPI_EmbedCredentials, having type bool + ParameterId["EmbedCredentials"] = "embedCredentials"; + // DPI_EmbedOAuthCredential, having type bool + ParameterId["EmbedOAuthCredential"] = "embedOauthCredentials"; + // DPI_EmptyHighlightFogAll, having type bool + ParameterId["EmptyHighlightFogAll"] = "emptyHighlightFogAll"; + // DPI_EnableAlphabeticSort, having type bool + ParameterId["EnableAlphabeticSort"] = "enableAlphabeticSort"; + // DPI_EnableAutomaticDrill, having type bool + ParameterId["EnableAutomaticDrill"] = "enableAutomaticDrill"; + // DPI_EnableConfidenceBands, having type bool + ParameterId["EnableConfidenceBands"] = "enableConfidenceBands"; + // DPI_EnableDataOrderSort, having type bool + ParameterId["EnableDataOrderSort"] = "enableDataOrderSort"; + // DPI_EnableFieldSort, having type bool + ParameterId["EnableFieldSort"] = "enableFieldSort"; + // DPI_EnableInstantAnalytics, having type bool + ParameterId["EnableInstantAnalytics"] = "enableInstantAnalytics"; + // DPI_EnableLines, having type bool + ParameterId["EnableLines"] = "enableLines"; + // DPI_EnableManualSort, having type bool + ParameterId["EnableManualSort"] = "enableManualSort"; + // DPI_EnableMarks, having type bool + ParameterId["EnableMarks"] = "enableMarks"; + // DPI_EnableMultipleSelection, having type bool + ParameterId["EnableMultipleSelection"] = "enableMultipleSelection"; + // DPI_EnablePrefetching, having type bool + ParameterId["EnablePrefetching"] = "enablePrefetching"; + // DPI_EnableTableCalcDensification, having type bool + ParameterId["EnableTableCalcDensification"] = "enableTableCalcDensification"; + // DPI_EnableTooltips, having type bool + ParameterId["EnableTooltips"] = "enableTooltips"; + // DPI_EndDataSourcePresModelUpdate, having type bool + ParameterId["EndDataSourcePresModelUpdate"] = "endDataSourcePresModelUpdate"; + // DPI_EstimateNulls, having type bool + ParameterId["EstimateNulls"] = "estimateNulls"; + // DPI_Exclude, having type bool + ParameterId["Exclude"] = "exclude"; + // DPI_ExcludeColor, having type bool + ParameterId["ExcludeColor"] = "excludeColor"; + // DPI_ExcludeCubeDenorm, having type bool + ParameterId["ExcludeCubeDenorm"] = "excludeCubeDenorm"; + // DPI_ExcludeInterceptEnabled, having type bool + ParameterId["ExcludeInterceptEnabled"] = "excludeInterceptEnabled"; + // DPI_ExcludeLocalFunctions, having type bool + ParameterId["ExcludeLocalFunctions"] = "excludeLocalFunctions"; + // DPI_ExportDashboardImageFromSheet, having type bool + ParameterId["ExportDashboardImageFromSheet"] = "exportImageSheetAsDashboard"; + // DPI_ExtSvcConfigIsAuthEnabled, having type bool + ParameterId["ExtSvcConfigIsAuthEnabled"] = "extSvcConfigIsAuthEnabled"; + // DPI_ExtractFullRefresh, having type bool + ParameterId["ExtractFullRefresh"] = "extractFullRefresh"; + // DPI_ExtractNeedsRefresh, having type bool + ParameterId["ExtractNeedsRefresh"] = "extractNeedsRefresh"; + // DPI_ExtractPending, having type bool + ParameterId["ExtractPending"] = "extractPending"; + // DPI_ExtractSelected, having type bool + ParameterId["ExtractSelected"] = "extractSelected"; + // DPI_FederatableOnly, having type bool + ParameterId["FederatableOnly"] = "federatableOnly"; + // DPI_FieldSortOrder, having type bool + ParameterId["FieldSortOrder"] = "fieldSortOrder"; + // DPI_FieldSupportsContains, having type bool + ParameterId["FieldSupportsContains"] = "fieldSupportsContains"; + // DPI_FieldSupportsEndsWith, having type bool + ParameterId["FieldSupportsEndsWith"] = "fieldSupportsEndsWith"; + // DPI_FieldSupportsStartsWith, having type bool + ParameterId["FieldSupportsStartsWith"] = "fieldSupportsStartsWith"; + // DPI_FillAbove, having type bool + ParameterId["FillAbove"] = "fillAbove"; + // DPI_FillBelow, having type bool + ParameterId["FillBelow"] = "fillBelow"; + // DPI_FillWithZeroes, having type bool + ParameterId["FillWithZeroes"] = "fillZeroes"; + // DPI_FilterIsNamed, having type bool + ParameterId["FilterIsNamed"] = "filterIsNamed"; + // DPI_Focus, having type bool + ParameterId["Focus"] = "focus"; + // DPI_ForInternalUse, having type bool + ParameterId["ForInternalUse"] = "internalUse"; + // DPI_ForceBrowserRendering, having type bool + ParameterId["ForceBrowserRendering"] = "forceBrowserRendering"; + // DPI_ForceCache, having type bool + ParameterId["ForceCache"] = "forceCache"; + // DPI_ForceColorFromApp, having type bool + ParameterId["ForceColorFromApp"] = "forceColorFromApp"; + // DPI_ForceConnectionAttempt, having type bool + ParameterId["ForceConnectionAttempt"] = "forceConnectionAttempt"; + // DPI_ForceConsolidateInCommit, having type bool + ParameterId["ForceConsolidateInCommit"] = "forceConsolidateInCommit"; + // DPI_ForceExtractRefresh, having type bool + ParameterId["ForceExtractRefresh"] = "extractForceRefresh"; + // DPI_ForceInterceptZero, having type bool + ParameterId["ForceInterceptZero"] = "forceInterceptZero"; + // DPI_ForceOldConnectExperience, having type bool + ParameterId["ForceOldConnectExperience"] = "forceOldConnectExperience"; + // DPI_ForceRelativeDate, having type bool + ParameterId["ForceRelativeDate"] = "forceRelativeDate"; + // DPI_ForceToggleHighlightStateOn, having type bool + ParameterId["ForceToggleHighlightStateOn"] = "forceHighlightOn"; + // DPI_ForceUserToChoose, having type bool + ParameterId["ForceUserToChoose"] = "forceUserToChoose"; + // DPI_ForceWholeDate, having type bool + ParameterId["ForceWholeDate"] = "forceWholeDate"; + // DPI_ForecastSelected, having type bool + ParameterId["ForecastSelected"] = "forecastSelected"; + // DPI_ForecastUseAutoAgg, having type bool + ParameterId["ForecastUseAutoAgg"] = "forecastUseAutoSummarize"; + // DPI_ForJoin, having type bool + ParameterId["ForJoin"] = "forJoin"; + // DPI_FormatDataValueLocally, having type bool + ParameterId["FormatDataValueLocally"] = "formatDataValueLocally"; + // DPI_FormatIfColumn, having type bool + ParameterId["FormatIfColumn"] = "formatIfColumn"; + // DPI_FormatIfParameter, having type bool + ParameterId["FormatIfParameter"] = "formatIfParameter"; + // DPI_GeographicSearchIsDataLoaded, having type bool + ParameterId["GeographicSearchIsDataLoaded"] = "geographicSearchDataLoaded"; + // DPI_GeographicSearchLoadDataAsync, having type bool + ParameterId["GeographicSearchLoadDataAsync"] = "geographicSearchLoadDataAsync"; + // DPI_GroupByAll, having type bool + ParameterId["GroupByAll"] = "groupByAll"; + // DPI_HasAlias, having type bool + ParameterId["HasAlias"] = "hasAlias"; + // DPI_HasAllMember, having type bool + ParameterId["HasAllMember"] = "hasAllMember"; + // DPI_HasApply, having type bool + ParameterId["HasApply"] = "hasApply"; + // DPI_HasBackgroundImage, having type bool + ParameterId["HasBackgroundImage"] = "hasBackgroundImage"; + // DPI_HasBeenDismissed, having type bool + ParameterId["HasBeenDismissed"] = "hasBeenDismissed"; + // DPI_HasCaption, having type bool + ParameterId["HasCaption"] = "hasCaption"; + // DPI_HasCondition, having type bool + ParameterId["HasCondition"] = "hasCondition"; + // DPI_HasConnectPermissions, having type bool + ParameterId["HasConnectPermissions"] = "hasConnectPermissions"; + // DPI_HasDashboard, having type bool + ParameterId["HasDashboard"] = "hasDashboard"; + // DPI_HasDownloadPermissions, having type bool + ParameterId["HasDownloadPermissions"] = "hasDownloadPermissions"; + // DPI_HasDrill, having type bool + ParameterId["HasDrill"] = "hasDrill"; + // DPI_HasExclude, having type bool + ParameterId["HasExclude"] = "hasExclude"; + // DPI_HasFill, having type bool + ParameterId["HasFill"] = "hasFill"; + // DPI_HasLabels, having type bool + ParameterId["HasLabels"] = "hasLabels"; + // DPI_HasLimit, having type bool + ParameterId["HasLimit"] = "hasLimit"; + // DPI_HasLine, having type bool + ParameterId["HasLine"] = "hasLine"; + // DPI_HasModifiedAxes, having type bool + ParameterId["HasModifiedAxes"] = "hasModifiedAxes"; + // DPI_HasNonRootCalculations, having type bool + ParameterId["HasNonRootCalculations"] = "hasNonRootCalculations"; + // DPI_HasOnlyOneHierarchy, having type bool + ParameterId["HasOnlyOneHierarchy"] = "hasOnlyOneHierarchy"; + // DPI_HasPattern, having type bool + ParameterId["HasPattern"] = "hasPattern"; + // DPI_HasPublishGuidanceResults, having type bool + ParameterId["HasPublishGuidanceResults"] = "hasPublishGuidanceResults"; + // DPI_HasSelection, having type bool + ParameterId["HasSelection"] = "hasSelection"; + // DPI_HasServerCredentials, having type bool + ParameterId["HasServerCredentials"] = "hasServerCredentials"; + // DPI_HasSpace, having type bool + ParameterId["HasSpace"] = "hasSpace"; + // DPI_HasStoredProcedure, having type bool + ParameterId["HasStoredProcedure"] = "hasStoredProcedure"; + // DPI_HasStringCalculatedMeasures, having type bool + ParameterId["HasStringCalculatedMeasures"] = "hasStringCalculatedMeasures"; + // DPI_HasTableCalcData, having type bool + ParameterId["HasTableCalcData"] = "hasTableCalcData"; + // DPI_HasTitle, having type bool + ParameterId["HasTitle"] = "hasTitle"; + // DPI_HasUserSpecificContent, having type bool + ParameterId["HasUserSpecificContent"] = "hasUserSpecificContent"; + // DPI_HasUnjoinedTable, having type bool + ParameterId["HasUnjoinedTable"] = "hasUnjoinedTable"; + // DPI_HasVarArgs, having type bool + ParameterId["HasVarArgs"] = "hasVarArgs"; + // DPI_HasVisitedWDCPage, having type bool + ParameterId["HasVisitedWDCPage"] = "hasVisitedWdcPage"; + // DPI_IgnoreAliases, having type bool + ParameterId["IgnoreAliases"] = "ignoreAliases"; + // DPI_IgnoreDomain, having type bool + ParameterId["IgnoreDomain"] = "ignoreDomain"; + // DPI_IgnoreSelection, having type bool + ParameterId["IgnoreSelection"] = "ignoreSelection"; + // DPI_IncludeAllColumns, having type bool + ParameterId["IncludeAllColumns"] = "includeAllColumns"; + // DPI_IncludeContext, having type bool + ParameterId["IncludeContext"] = "includeContext"; + // DPI_IncludeDashboardPresModels, having type bool + ParameterId["IncludeDashboardPresModels"] = "includeDashboardPresModels"; + // DPI_IncludeItemSet, having type bool + ParameterId["IncludeItemSet"] = "includeItemSet"; + // DPI_IncludeLocalFiles, having type bool + ParameterId["IncludeLocalFiles"] = "includeLocalFiles"; + // DPI_IncludeOtherSelected, having type bool + ParameterId["IncludeOtherSelected"] = "includeOtherSelected"; + // DPI_IncludeNulls, having type bool + ParameterId["IncludeNulls"] = "includeNulls"; + // DPI_IncludeParent, having type bool + ParameterId["IncludeParent"] = "includeParent"; + // DPI_IncludeSelections, having type bool + ParameterId["IncludeSelections"] = "includeSelections"; + // DPI_IncludeSiblings, having type bool + ParameterId["IncludeSiblings"] = "includeSiblings"; + // DPI_IncludeStories, having type bool + ParameterId["IncludeStories"] = "includeStories"; + // DPI_IncludeSubfolders, having type bool + ParameterId["IncludeSubfolders"] = "includeSubfolders"; + // DPI_IncludeVolatileProps, having type bool + ParameterId["IncludeVolatileProps"] = "includeVolatileProps"; + // DPI_IncludesTag, having type bool + ParameterId["IncludesTag"] = "includesTag"; + // DPI_InsertAfter, having type bool + ParameterId["InsertAfter"] = "insertAfter"; + // DPI_InsertAtEnd, having type bool + ParameterId["InsertAtEnd"] = "insertAtEnd"; + // DPI_InstantAnalyticsAllowed, having type bool + ParameterId["InstantAnalyticsAllowed"] = "instantAnalyticsAllowed"; + // DPI_IntegerCoordinates, having type bool + ParameterId["IntegerCoordinates"] = "intCoords"; + // DPI_InvalidatedLayout, having type bool + ParameterId["InvalidatedLayout"] = "invalidatedLayout"; + // DPI_IsActive, having type bool + ParameterId["IsActive"] = "isActive"; + // DPI_IsAddToFilter, having type bool + ParameterId["IsAddToFilter"] = "isAddToFilterButtonChecked"; + // DPI_IsAllButtonVisible, having type bool + ParameterId["IsAllButtonVisible"] = "isAllButtonVisible"; + // DPI_IsAllowedInCalcs, having type bool + ParameterId["IsAllowedInCalcs"] = "isAllowedInCalcs"; + // DPI_IsAppMapSource, having type bool + ParameterId["IsAppMapSource"] = "isAppMapSource"; + // DPI_IsArchive, having type bool + ParameterId["IsArchive"] = "isArchive"; + // DPI_IsAttributeHierarchy, having type bool + ParameterId["IsAttributeHierarchy"] = "isAttributeHierarchy"; + // DPI_IsAuthoringMode, having type bool + ParameterId["IsAuthoringMode"] = "isAuthoringMode"; + // DPI_IsAuto, having type bool + ParameterId["IsAuto"] = "isAuto"; + // DPI_IsAutoClear, having type bool + ParameterId["IsAutoClear"] = "isAutoClear"; + // DPI_IsAutoColumn, having type bool + ParameterId["IsAutoColumn"] = "isAutoColumn"; + // DPI_IsAutoHidden, having type bool + ParameterId["IsAutoHidden"] = "isAutoHidden"; + // DPI_IsAutoSelect, having type bool + ParameterId["IsAutoSelect"] = "isAutoSelect"; + // DPI_IsBold, having type bool + ParameterId["IsBold"] = "isBold"; + // DPI_IsBorderVisible, having type bool + ParameterId["IsBorderVisible"] = "isBorderVisible"; + // DPI_IsBoxplot, having type bool + ParameterId["IsBoxplot"] = "isBoxplot"; + // DPI_IsCapable, having type bool + ParameterId["IsCapable"] = "isCapable"; + // DPI_IsCaptured, having type bool + ParameterId["IsCaptured"] = "isCaptured"; + // DPI_IsCentered, having type bool + ParameterId["IsCentered"] = "isCentered"; + // DPI_IsChecked, having type bool + ParameterId["IsChecked"] = "isChecked"; + // DPI_IsColorDiverging, having type bool + ParameterId["IsColorDiverging"] = "isColorDiverging"; + // DPI_IsColorStepped, having type bool + ParameterId["IsColorStepped"] = "isColorStepped"; + // DPI_IsCombinedField, having type bool + ParameterId["IsCombinedField"] = "isCombinedField"; + // DPI_IsConnected, having type bool + ParameterId["IsConnected"] = "isConnected"; + // DPI_IsContextMenuAllowed, having type bool + ParameterId["IsContextMenuAllowed"] = "isContextMenuAllowed"; + // DPI_IsContinuous, having type bool + ParameterId["IsContinuous"] = "isContinuous"; + // DPI_IsCopy, having type bool + ParameterId["IsCopy"] = "isCopy"; + // DPI_IsCustomCalculation, having type bool + ParameterId["IsCustomCalculation"] = "isCustomCalculation"; + // DPI_IsCustomPalette, having type bool + ParameterId["IsCustomPalette"] = "isCustomPalette"; + // DPI_IsCustomSQL, having type bool + ParameterId["IsCustomSQL"] = "isCustomSql"; + // DPI_IsCustomValueEnabled, having type bool + ParameterId["IsCustomValueEnabled"] = "isCustomValueEnabled"; + // DPI_IsDataAlertConditionMet, having type bool + ParameterId["IsDataAlertConditionMet"] = "isDataAlertConditionMet"; + // DPI_IsDataAlertDialogVisible, having type bool + ParameterId["IsDataAlertDialogVisible"] = "isDataAlertDialogVisible"; + // DPI_IsDataBin, having type bool + ParameterId["IsDataBin"] = "isDataBin"; + // DPI_IsDataGridVisible, having type bool + ParameterId["IsDataGridVisible"] = "isDataGridVisible"; + // DPI_IsDatabase, having type bool + ParameterId["IsDatabase"] = "isDatabase"; + // DPI_IsDatabaseFilterInclusive, having type bool + ParameterId["IsDatabaseFilterInclusive"] = "isDbFilterInclusive"; + // DPI_IsDraggable, having type bool + ParameterId["IsDraggable"] = "isDraggable"; + // DPI_IsMDXCalculation, having type bool + ParameterId["IsMDXCalculation"] = "isMdxCalculation"; + // DPI_IsMetadata, having type bool + ParameterId["IsMetadata"] = "isMetadata"; + // DPI_IsWebDataTabViewSupported, having type bool + ParameterId["IsWebDataTabViewSupported"] = "isWebDataTabViewSupported"; + // DPI_IsPublishedDatasourceReplacement, having type bool + ParameterId["IsPublishedDatasourceReplacement"] = "isPublishedDatasourceReplacement"; + // DPI_IsDeadDrop, having type bool + ParameterId["IsDeadDrop"] = "isDeadDrop"; + // DPI_IsDefault, having type bool + ParameterId["IsDefault"] = "isDefault"; + // DPI_IsDeleteCalcConfirm, having type bool + ParameterId["IsDeleteCalcConfirm"] = "isDeleteCalcConfirmed"; + // DPI_IsDimension, having type bool + ParameterId["IsDimension"] = "isDimension"; + // DPI_IsDisabled, having type bool + ParameterId["IsDisabled"] = "isDisabled"; + // DPI_IsDivider, having type bool + ParameterId["IsDivider"] = "isDivider"; + // DPI_IsDropdownEnabled, having type bool + ParameterId["IsDropdownEnabled"] = "isDropdownEnabled"; + // DPI_IsEditing, having type bool + ParameterId["IsEditing"] = "isEditing"; + // DPI_IsEmbedded, having type bool + ParameterId["IsEmbedded"] = "isEmbedded"; + // DPI_IsEmpty, having type bool + ParameterId["IsEmpty"] = "isEmpty"; + // DPI_IsAddInEnabled, having type bool + ParameterId["IsAddInEnabled"] = "isAddInEnabled"; + // DPI_IsInDrillPath, having type bool + ParameterId["IsInDrillPath"] = "isInDrillPath"; + // DPI_AddInJSDebuggingEnabled, having type bool + ParameterId["AddInJSDebuggingEnabled"] = "addInJsDebugginEnabled"; + // DPI_AddInPauseBeforeLoading, having type bool + ParameterId["AddInPauseBeforeLoading"] = "addInPauseBeforeLoading"; + // DPI_IsDSHierarchical, having type bool + ParameterId["IsDSHierarchical"] = "isDsHierarchical"; + // DPI_IsEditorOpen, having type bool + ParameterId["IsEditorOpen"] = "isEditorOpen"; + // DPI_IsEndPtMoveable, having type bool + ParameterId["IsEndPtMoveable"] = "isEndpointMovable"; + // DPI_IsExclude, having type bool + ParameterId["IsExclude"] = "isExcludeButtonChecked"; + // DPI_IsExistingConnection, having type bool + ParameterId["IsExistingConnection"] = "isExistingConnection"; + // DPI_IsExistingObject, having type bool + ParameterId["IsExistingObject"] = "isExistingObject"; + // DPI_IsExtract, having type bool + ParameterId["IsExtract"] = "isExtract"; + // DPI_IsExtractOnlyConnection, having type bool + ParameterId["IsExtractOnlyConnection"] = "isExtractOnlyConnection"; + // DPI_IsExtractSelectionVisible, having type bool + ParameterId["IsExtractSelectionVisible"] = "isExtractSelectionVisible"; + // DPI_IsFederatable, having type bool + ParameterId["IsFederatable"] = "isFederatable"; + // DPI_IsField, having type bool + ParameterId["IsField"] = "isField"; + // DPI_IsFieldParameter, having type bool + ParameterId["IsFieldParameter"] = "isFieldParameter"; + // DPI_IsFilterActionField, having type bool + ParameterId["IsFilterActionField"] = "isFilterActionField"; + // DPI_IsFirstClassConnector, having type bool + ParameterId["IsFirstClassConnector"] = "isFirstClassConnector"; + // DPI_IsFloating, having type bool + ParameterId["IsFloating"] = "isFloating"; + // DPI_IsFolded, having type bool + ParameterId["IsFolded"] = "isFolded"; + // DPI_IsForInput, having type bool + ParameterId["IsForInput"] = "isForInput"; + // DPI_IsForecastEnabled, having type bool + ParameterId["IsForecastEnabled"] = "isForecastEnabled"; + // DPI_IsForceDirty, having type bool + ParameterId["IsForceDirty"] = "isForceDirty"; + // DPI_IsFullScan, having type bool + ParameterId["IsFullScan"] = "isFullScan"; + // DPI_IsFullStyling, having type bool + ParameterId["IsFullStyling"] = "isFullStyling"; + // DPI_IsGenerated, having type bool + ParameterId["IsGenerated"] = "isGenerated"; + // DPI_IsGlobalNames, having type bool + ParameterId["IsGlobalNames"] = "isGlobalNames"; + // DPI_IsGrayed, having type bool + ParameterId["IsGrayed"] = "isGrayed"; + // DPI_IsGrayscale, having type bool + ParameterId["IsGrayscale"] = "isGrayscale"; + // DPI_IsGroup, having type bool + ParameterId["IsGroup"] = "isGroup"; + // DPI_IsHideableField, having type bool + ParameterId["IsHideableField"] = "isHideableField"; + // DPI_IsHierarchy, having type bool + ParameterId["IsHierarchy"] = "isHierarchy"; + // DPI_IsHierarchySingleSelect, having type bool + ParameterId["IsHierarchySingleSelect"] = "isHierarchySingleSelect"; + // DPI_IsHighlightAllowed, having type bool + ParameterId["IsHighlightAllowed"] = "isHighlightAllowed"; + // DPI_IsHighlightEnabled, having type bool + ParameterId["IsHighlightEnabled"] = "isHighlightEnabled"; + // DPI_IsHighlightField, having type bool + ParameterId["IsHighlightField"] = "isHighlightField"; + // DPI_IsHorizontal, having type bool + ParameterId["IsHorizontal"] = "isHorizontal"; + // DPI_IsImageEnabled, having type bool + ParameterId["IsImageEnabled"] = "isImageEnabled"; + // DPI_IsInDefault, having type bool + ParameterId["IsInDefault"] = "isInDefault"; + // DPI_IsInPrimaryDataSource, having type bool + ParameterId["IsInPrimaryDataSource"] = "isInPrimaryDataSource"; + // DPI_IsInner, having type bool + ParameterId["IsInner"] = "isInner"; + // DPI_IsInstance, having type bool + ParameterId["IsInstance"] = "isInstance"; + // DPI_IsInvalid, having type bool + ParameterId["IsInvalid"] = "isInvalid"; + // DPI_IsInvalidCalcOnDG, having type bool + ParameterId["IsInvalidCalcOnDG"] = "isInvalidDgCalc"; + // DPI_IsItalics, having type bool + ParameterId["IsItalics"] = "isItalics"; + // DPI_IsJoinAreaVisible, having type bool + ParameterId["IsJoinAreaVisible"] = "isJoinAreaVisible"; + // DPI_IsLabels, having type bool + ParameterId["IsLabels"] = "isLabels"; + // DPI_IsLayered, having type bool + ParameterId["IsLayered"] = "isLayered"; + // DPI_IsLeft, having type bool + ParameterId["IsLeft"] = "isLeft"; + // DPI_IsLegacy, having type bool + ParameterId["IsLegacy"] = "isLegacy"; + // DPI_IsLevel, having type bool + ParameterId["IsLevel"] = "isLevel"; + // DPI_IsLevelOrLevelIdentity, having type bool + ParameterId["IsLevelOrLevelIdentity"] = "isLevelOrLevelIdentity"; + // DPI_IsLicensed, having type bool + ParameterId["IsLicensed"] = "isLicensed"; + // DPI_IsLink, having type bool + ParameterId["IsLink"] = "isLink"; + // DPI_IsLinked, having type bool + ParameterId["IsLinked"] = "isLinked"; + // DPI_IsMap, having type bool + ParameterId["IsMap"] = "isMap"; + // DPI_IsMeasure, having type bool + ParameterId["IsMeasure"] = "isMeasure"; + // DPI_IsMerge, having type bool + ParameterId["IsMerge"] = "isMerge"; + // DPI_IsMessageSourceRemote, having type bool + ParameterId["IsMessageSourceRemote"] = "isMessageSourceRemote"; + // DPI_IsMissingFromExtract, having type bool + ParameterId["IsMissingFromExtract"] = "isMissingFromExtract"; + // DPI_IsMobile, having type bool + ParameterId["IsMobile"] = "isMobile"; + // DPI_IsModified, having type bool + ParameterId["IsModified"] = "isModified"; + // DPI_IsNew, having type bool + ParameterId["IsNew"] = "isNew"; + // DPI_IsNewCloudFileDataSource, having type bool + ParameterId["IsNewCloudFileDataSource"] = "isNewCloudFileDataSource"; + // DPI_IsNewZone, having type bool + ParameterId["IsNewZone"] = "isNewZone"; + // DPI_IsNone, having type bool + ParameterId["IsNone"] = "isNone"; + // DPI_IsOfflineMode, having type bool + ParameterId["IsOfflineMode"] = "isOfflineMode"; + // DPI_IsPreAqlBin, having type bool + ParameterId["IsPreAqlBin"] = "isPreAqlBin"; + // DPI_IsOMeasuresAndRelational, having type bool + ParameterId["IsOMeasuresAndRelational"] = "isOmeasuresAndRelational"; + // DPI_IsOpaque, having type bool + ParameterId["IsOpaque"] = "isOpaque"; + // DPI_IsOrphaned, having type bool + ParameterId["IsOrphaned"] = "isOrphaned"; + // DPI_IsOverlay, having type bool + ParameterId["IsOverlay"] = "isOverlay"; + // DPI_IsOverride, having type bool + ParameterId["IsOverride"] = "isOverride"; + // DPI_IsPageLoading, having type bool + ParameterId["IsPageLoading"] = "isPageLoading"; + // DPI_IsParameterSelected, having type bool + ParameterId["IsParameterSelected"] = "isParameterSelected"; + // DPI_IsParameterSelectedOnFrom, having type bool + ParameterId["IsParameterSelectedOnFrom"] = "isParameterSelectedOnFrom"; + // DPI_IsParameterSelectedOnTo, having type bool + ParameterId["IsParameterSelectedOnTo"] = "isParameterSelectedOnTo"; + // DPI_IsPatternBased, having type bool + ParameterId["IsPatternBased"] = "isPatternBased"; + // DPI_IsPinned, having type bool + ParameterId["IsPinned"] = "isPinned"; + // DPI_IsPresentationMode, having type bool + ParameterId["IsPresentationMode"] = "isPresentationModeDoc"; + // DPI_IsPublishAllowed, having type bool + ParameterId["IsPublishAllowed"] = "isPublishAllowed"; + // DPI_IsMustDowngradeToPublish, having type bool + ParameterId["IsMustDowngradeToPublish"] = "isDowngradeToPublishRequired"; + // DPI_IsPublished, having type bool + ParameterId["IsPublished"] = "isPublished"; + // DPI_IsQuantitative, having type bool + ParameterId["IsQuantitative"] = "isQuantitative"; + // DPI_IsQuickTableCalc, having type bool + ParameterId["IsQuickTableCalc"] = "isQuickTableCalc"; + // DPI_IsRadioOn, having type bool + ParameterId["IsRadioOn"] = "isRadioOn"; + // DPI_IsReconnect, having type bool + ParameterId["IsReconnect"] = "isReconnect"; + // DPI_IsRecursive, having type bool + ParameterId["IsRecursive"] = "isRecursive"; + // DPI_IsReferenced, having type bool + ParameterId["IsReferenced"] = "isReferenced"; + // DPI_IsRemovalAllowed, having type bool + ParameterId["IsRemovalAllowed"] = "isRowRemovalAllowed"; + // DPI_IsRenderCapable, having type bool + ParameterId["IsRenderCapable"] = "isRenderCapable"; + // DPI_IsRequired, having type bool + ParameterId["IsRequired"] = "isRequired"; + // DPI_IsReversed, having type bool + ParameterId["IsReversed"] = "isReversed"; + // DPI_IsRightDrag, having type bool + ParameterId["IsRightDrag"] = "isRightDrag"; + // DPI_IsRowLabels, having type bool + ParameterId["IsRowLabels"] = "isRowLabels"; + // DPI_IsPercentage, having type bool + ParameterId["IsPercentage"] = "isPercentage"; + // DPI_IsSalesforceInConnection, having type bool + ParameterId["IsSalesforceInConnection"] = "isSalesforceInConnection"; + // DPI_IsScaled, having type bool + ParameterId["IsScaled"] = "isScaled"; + // DPI_IsSecondaryField, having type bool + ParameterId["IsSecondaryField"] = "isSecondaryField"; + // DPI_IsSelected, having type bool + ParameterId["IsSelected"] = "isSelected"; + // DPI_IsSelectedItem, having type bool + ParameterId["IsSelectedItem"] = "isSelectedItem"; + // DPI_IsSelectionDisabled, having type bool + ParameterId["IsSelectionDisabled"] = "isSelectionDisabled"; + // DPI_IsShiftDrag, having type bool + ParameterId["IsShiftDrag"] = "isShiftDrag"; + // DPI_IsSingleLabel, having type bool + ParameterId["IsSingleLabel"] = "isSingleLabel"; + // DPI_IsSingleSelect, having type bool + ParameterId["IsSingleSelect"] = "isSingleSelect"; + // DPI_IsSingleSelectMode, having type bool + ParameterId["IsSingleSelectMode"] = "isSingleSelectMode"; + // DPI_IsSingleSelection, having type bool + ParameterId["IsSingleSelection"] = "isSingleSelection"; + // DPI_IsSorted, having type bool + ParameterId["IsSorted"] = "isSorted"; + // DPI_IsSortPill, having type bool + ParameterId["IsSortPill"] = "isSortPill"; + // DPI_IsSpecial, having type bool + ParameterId["IsSpecial"] = "isSpecial"; + // DPI_IsSplashScreen, having type bool + ParameterId["IsSplashScreen"] = "isSplashScreen"; + // DPI_IsStoryEmpty, having type bool + ParameterId["IsStoryEmpty"] = "isStoryEmpty"; + // DPI_IsStrikeThrough, having type bool + ParameterId["IsStrikeThrough"] = "isStrikeThrough"; + // DPI_IsTableCalc, having type bool + ParameterId["IsTableCalc"] = "isTableCalc"; + // DPI_IsTableCleaningSubtable, having type bool + ParameterId["IsTableCleaningSubtable"] = "isTableCleaningSubtable"; + // DPI_IsTableFilterInclusive, having type bool + ParameterId["IsTableFilterInclusive"] = "isTableFilterInclusive"; + // DPI_IsTableRanked, having type bool + ParameterId["IsTableRanked"] = "isTableRanked"; + // DPI_IsTemporary, having type bool + ParameterId["IsTemporary"] = "isTemporary"; + // DPI_IsTimeIntelligence, having type bool + ParameterId["IsTimeIntelligence"] = "isTimeIntelligence"; + // DPI_IsTitleVisible, having type bool + ParameterId["IsTitleVisible"] = "isTitleVisible"; + // DPI_IsTopLevel, having type bool + ParameterId["IsTopLevel"] = "isTopLevel"; + // DPI_IsTwoValued, having type bool + ParameterId["IsTwoValued"] = "isTwoValued"; + // DPI_IsTypeInFinished, having type bool + ParameterId["IsTypeInFinished"] = "isTypeinFinished"; + // DPI_IsTypeInPill, having type bool + ParameterId["IsTypeInPill"] = "isTypeInPill"; + // DPI_IsURLActionField, having type bool + ParameterId["IsURLActionField"] = "isUrlActionField"; + // DPI_IsUnderlined, having type bool + ParameterId["IsUnderlined"] = "isUnderlined"; + // DPI_IsUnion, having type bool + ParameterId["IsUnion"] = "isUnion"; + // DPI_IsUnionReplacement, having type bool + ParameterId["IsUnionReplacement"] = "isUnionReplacement"; + // DPI_IsUnnamedCalc, having type bool + ParameterId["IsUnnamedCalc"] = "isUnnamed"; + // DPI_IsUserDefinedAttribute, having type bool + ParameterId["IsUserDefinedAttribute"] = "isUserDefinedAttribute"; + // DPI_IsUserEditable, having type bool + ParameterId["IsUserEditable"] = "isUserEditable"; + // DPI_IsUserPrompted, having type bool + ParameterId["IsUserPrompted"] = "isUserPrompted"; + // DPI_IsUserResponded, having type bool + ParameterId["IsUserResponded"] = "isUserResponded"; + // DPI_IsValid, having type bool + ParameterId["IsValid"] = "isValid"; + // DPI_IsValidWDCPage, having type bool + ParameterId["IsValidWDCPage"] = "isValidWdcPage"; + // DPI_IsVaryingAttributeDimension, having type bool + ParameterId["IsVaryingAttributeDimension"] = "isVaryingAttributeDimension"; + // DPI_IsVertical, having type bool + ParameterId["IsVertical"] = "isVertical"; + // DPI_IsViewModified, having type bool + ParameterId["IsViewModified"] = "isViewModified"; + // DPI_IsVisuallyCategorical, having type bool + ParameterId["IsVisuallyCategorical"] = "isVisuallyCat"; + // DPI_IsVizInTooltip, having type bool + ParameterId["IsVizInTooltip"] = "isVizInTooltip"; + // DPI_IsWeb, having type bool + ParameterId["IsWeb"] = "isWeb"; + // DPI_IsWhite, having type bool + ParameterId["IsWhite"] = "isWhite"; + // DPI_IsWorldNew, having type bool + ParameterId["IsWorldNew"] = "isWorldNew"; + // DPI_IsXAxis, having type bool + ParameterId["IsXAxis"] = "isXAxis"; + // DPI_KeepAspectRatio, having type bool + ParameterId["KeepAspectRatio"] = "keepAspectRatio"; + // DPI_LabelLineEndFirst, having type bool + ParameterId["LabelLineEndFirst"] = "labelLineEndFirst"; + // DPI_LabelLineEndLast, having type bool + ParameterId["LabelLineEndLast"] = "labelLineEndLast"; + // DPI_LabelMarkMax, having type bool + ParameterId["LabelMarkMax"] = "labelMarkMax"; + // DPI_LabelMarkMin, having type bool + ParameterId["LabelMarkMin"] = "labelMarkMin"; + // DPI_LockAspectRatio, having type bool + ParameterId["LockAspectRatio"] = "lockAspectRatio"; + // DPI_LoopPlayback, having type bool + ParameterId["LoopPlayback"] = "loopPlayback"; + // DPI_LossyImages, having type bool + ParameterId["LossyImages"] = "lossyImages"; + // DPI_MakeGlobal, having type bool + ParameterId["MakeGlobal"] = "isMakeGlobal"; + // DPI_ManualSortOnly, having type bool + ParameterId["ManualSortOnly"] = "manualSortOnly"; + // DPI_MapBoxDefaultStyleSelected, having type bool + ParameterId["MapBoxDefaultStyleSelected"] = "mapboxDefaultStyleSelected"; + // DPI_MapBoxURLParseSuccessful, having type bool + ParameterId["MapBoxURLParseSuccessful"] = "mapboxUrlParseSuccessful"; + // DPI_MapClientRequestsMapTiles, having type bool + ParameterId["MapClientRequestsMapTiles"] = "clientRequestsMapTiles"; + // DPI_MapHasValidLayer, having type bool + ParameterId["MapHasValidLayer"] = "mapHasValidLayer"; + // DPI_MapShowAttribution, having type bool + ParameterId["MapShowAttribution"] = "showAttribution"; + // DPI_MarkLabelsVisibilityChanged, having type bool + ParameterId["MarkLabelsVisibilityChanged"] = "markLabelsVisibilityChanged"; + // DPI_MembersLoaded, having type bool + ParameterId["MembersLoaded"] = "membersLoaded"; + // DPI_MinimizeNames, having type bool + ParameterId["MinimizeNames"] = "useMinNames"; + // DPI_ModelsTime, having type bool + ParameterId["ModelsTime"] = "modelsTime"; + // DPI_MoveRefereceLineUp, having type bool + ParameterId["MoveRefereceLineUp"] = "moveReferenceLineUp"; + // DPI_MultiDataSources, having type bool + ParameterId["MultiDataSources"] = "multiDataSources"; + // DPI_NavArrowsVisible, having type bool + ParameterId["NavArrowsVisible"] = "navArrowsVisible"; + // DPI_OEMHasSplashScreen, having type bool + ParameterId["OEMHasSplashScreen"] = "oemHasSplashScreen"; + // DPI_OneWayBrushing, having type bool + ParameterId["OneWayBrushing"] = "oneWayBrushing"; + // DPI_OnlyAggregations, having type bool + ParameterId["OnlyAggregations"] = "onlyAggregations"; + // DPI_OnlyShowDateBins, having type bool + ParameterId["OnlyShowDateBins"] = "onlyShowDateBins"; + // DPI_OverrideAllowed, having type bool + ParameterId["OverrideAllowed"] = "overrideAllowed"; + // DPI_OverrideStackDumper, having type bool + ParameterId["OverrideStackDumper"] = "overrideStackDumper"; + // DPI_PageAutoColorLines, having type bool + ParameterId["PageAutoColorLines"] = "autoColorLines"; + // DPI_PageAutoColorMarks, having type bool + ParameterId["PageAutoColorMarks"] = "autoColorMarks"; + // DPI_PageHistoryFade, having type bool + ParameterId["PageHistoryFade"] = "historyFade"; + // DPI_PercentageBands, having type bool + ParameterId["PercentageBands"] = "percentageBands"; + // DPI_PercentilesAllowed, having type bool + ParameterId["PercentilesAllowed"] = "percentilesAllowed"; + // DPI_PublishWithRemoteQueryAgent, having type bool + ParameterId["PublishWithRemoteQueryAgent"] = "publishWithRemoteQueryAgent"; + // DPI_PreviousSheet, having type bool + ParameterId["PreviousSheet"] = "previousSheet"; + // DPI_PromptDeleteSheetsWithVizInTooltip, having type bool + ParameterId["PromptDeleteSheetsWithVizInTooltip"] = "promptDeleteSheetsWithVizInTooltip"; + // DPI_QuantilesAllowed, having type bool + ParameterId["QuantilesAllowed"] = "quantilesAllowed"; + // DPI_RadialDistanceHitTest, having type bool + ParameterId["RadialDistanceHitTest"] = "radialDistanceHitTest"; + // DPI_RefLineSelected, having type bool + ParameterId["RefLineSelected"] = "refLineSelected"; + // DPI_RemovedSheets, having type bool + ParameterId["RemovedSheets"] = "removedSheets"; + // DPI_RenderImagesAsUrls, having type bool + ParameterId["RenderImagesAsUrls"] = "imagesAsUrls"; + // DPI_RenderOnTop, having type bool + ParameterId["RenderOnTop"] = "renderOnTop"; + // DPI_RepeatHeadersLegends, having type bool + ParameterId["RepeatHeadersLegends"] = "repeatHeadersLegends"; + // DPI_ReplaceActiveConfig, having type bool + ParameterId["ReplaceActiveConfig"] = "replaceActiveConfig"; + // DPI_ReplaceDatasourceAfterPublish, having type bool + ParameterId["ReplaceDatasourceAfterPublish"] = "replaceDatasourceAfterPublish"; + // DPI_ReplaceDatasourceFailed, having type bool + ParameterId["ReplaceDatasourceFailed"] = "replaceDatasourceFailed"; + // DPI_ReplaceTde, having type bool + ParameterId["ReplaceTde"] = "replaceTde"; + // DPI_RequireSelection, having type bool + ParameterId["RequireSelection"] = "requireSelection"; + // DPI_RequiresDBVariables, having type bool + ParameterId["RequiresDBVariables"] = "requiresDbVariables"; + // DPI_RequiresFieldList, having type bool + ParameterId["RequiresFieldList"] = "requiresFieldList"; + // DPI_RestartEveryFieldIsInvalid, having type bool + ParameterId["RestartEveryFieldIsInvalid"] = "restartEveryFieldIsInvalid"; + // DPI_RightJustify, having type bool + ParameterId["RightJustify"] = "rightJustify"; + // DPI_SaveEnabled, having type bool + ParameterId["SaveEnabled"] = "saveEnabled"; + // DPI_SavePasswordAllowed, having type bool + ParameterId["SavePasswordAllowed"] = "savePasswordAllowed"; + // DPI_ScopeIsolation, having type bool + ParameterId["ScopeIsolation"] = "scopeIsolation"; + // DPI_SelectionRequired, having type bool + ParameterId["SelectionRequired"] = "selectionRequired"; + // DPI_SendNotifications, having type bool + ParameterId["SendNotifications"] = "sendNotifications"; + // DPI_SetActive, having type bool + ParameterId["SetActive"] = "setActive"; + // DPI_SetDefaultSort, having type bool + ParameterId["SetDefaultSort"] = "setDefault"; + // DPI_SheetIsDashboard, having type bool + ParameterId["SheetIsDashboard"] = "isDashboard"; + // DPI_SheetIsStoryboard, having type bool + ParameterId["SheetIsStoryboard"] = "isStory"; + // DPI_ShouldAlwaysDisplayAlias, having type bool + ParameterId["ShouldAlwaysDisplayAlias"] = "shouldAlwaysDisplayAlias"; + // DPI_ShouldAutoCapture, having type bool + ParameterId["ShouldAutoCapture"] = "shouldAutoCapture"; + // DPI_ShouldAutoRevert, having type bool + ParameterId["ShouldAutoRevert"] = "shouldAutoRevert"; + // DPI_ShouldChangeUIMode, having type bool + ParameterId["ShouldChangeUIMode"] = "shouldChangeUiMode"; + // DPI_ShouldDisplay, having type bool + ParameterId["ShouldDisplay"] = "shouldDisplay"; + // DPI_ShouldDrill, having type bool + ParameterId["ShouldDrill"] = "shouldDrill"; + // DPI_ShouldForceConnectionAttempt, having type bool + ParameterId["ShouldForceConnectionAttempt"] = "shouldForceConnectionAttempt"; + // DPI_ShouldRefreshDS, having type bool + ParameterId["ShouldRefreshDS"] = "shouldRefreshDs"; + // DPI_ShouldScaleMarksInAxisUnits, having type bool + ParameterId["ShouldScaleMarksInAxisUnits"] = "shouldScaleMarksInAxisUnits"; + // DPI_ShouldSeedCredentials, having type bool + ParameterId["ShouldSeedCredentials"] = "shouldSeedCredentials"; + // DPI_ShouldShowDataSourceConnectionError, having type bool + ParameterId["ShouldShowDataSourceConnectionError"] = "shouldShowDataSourceConnectionError"; + // DPI_ShouldShowDistance, having type bool + ParameterId["ShouldShowDistance"] = "shouldShowDistance"; + // DPI_ShouldShowHiddenField, having type bool + ParameterId["ShouldShowHiddenField"] = "shouldShowHiddenField"; + // DPI_ShouldShowMapScale, having type bool + ParameterId["ShouldShowMapScale"] = "shouldShowMapScale"; + // DPI_ShouldURLEscape, having type bool + ParameterId["ShouldURLEscape"] = "shouldUrlEscape"; + // DPI_ShouldUpdateDomainInfo, having type bool + ParameterId["ShouldUpdateDomainInfo"] = "shouldUpdateDomInfo"; + // DPI_ShowAddToFilter, having type bool + ParameterId["ShowAddToFilter"] = "showAddToFilterButton"; + // DPI_ShowAliases, having type bool + ParameterId["ShowAliases"] = "showAliases"; + // DPI_ShowAllPages, having type bool + ParameterId["ShowAllPages"] = "showAllPages"; + // DPI_ShowApply, having type bool + ParameterId["ShowApply"] = "showApplyButton"; + // DPI_ShowApplyAndCancelButtons, having type bool + ParameterId["ShowApplyAndCancelButtons"] = "showApplyAndCancelButtons"; + // DPI_ShowAuthenticationOptions, having type bool + ParameterId["ShowAuthenticationOptions"] = "showAuthenticationOptions"; + // DPI_ShowAuthenticationSetting, having type bool + ParameterId["ShowAuthenticationSetting"] = "showAuthenticationSetting"; + // DPI_ShowAuto, having type bool + ParameterId["ShowAuto"] = "showAuto"; + // DPI_ShowBold, having type bool + ParameterId["ShowBold"] = "showBoldOption"; + // DPI_ShowButtons, having type bool + ParameterId["ShowButtons"] = "showButtons"; + // DPI_ShowCaption, having type bool + ParameterId["ShowCaption"] = "showCaption"; + // DPI_ShowColorLegend, having type bool + ParameterId["ShowColorLegend"] = "showColorLegend"; + // DPI_ShowDataGridInlineRename, having type bool + ParameterId["ShowDataGridInlineRename"] = "showDataGridInlineRename"; + // DPI_ShowDetailMessages, having type bool + ParameterId["ShowDetailMessages"] = "showDetailMessages"; + // DPI_ShowDate, having type bool + ParameterId["ShowDate"] = "showDate"; + // DPI_ShowDragLabel, having type bool + ParameterId["ShowDragLabel"] = "showDragLabel"; + // DPI_ShowDropMeasures, having type bool + ParameterId["ShowDropMeasures"] = "showDropMeasures"; + // DPI_ShowEmbedAll, having type bool + ParameterId["ShowEmbedAll"] = "showEmbedAll"; + // DPI_ShowEntireImage, having type bool + ParameterId["ShowEntireImage"] = "showEntireImage"; + // DPI_ShowExclude, having type bool + ParameterId["ShowExclude"] = "showExcludeButton"; + // DPI_ShowFloatingZoomToolbar, having type bool + ParameterId["ShowFloatingZoomToolbar"] = "showFloatingZoomToolbar"; + // DPI_ShowFormatter, having type bool + ParameterId["ShowFormatter"] = "showFormatter"; + // DPI_ShowFullSchedules, having type bool + ParameterId["ShowFullSchedules"] = "showFullSchedules"; + // DPI_ShowGeographicSearch, having type bool + ParameterId["ShowGeographicSearch"] = "showGeographicSearch"; + // DPI_ShowHiddenFields, having type bool + ParameterId["ShowHiddenFields"] = "showHiddenFields"; + // DPI_ShowHistoryControls, having type bool + ParameterId["ShowHistoryControls"] = "showHistoryControls"; + // DPI_ShowIncludeLocalFiles, having type bool + ParameterId["ShowIncludeLocalFiles"] = "showIncludeLocalFiles"; + // DPI_ShowIncludeOtherOption, having type bool + ParameterId["ShowIncludeOtherOption"] = "showIncludeOtherOption"; + // DPI_ShowIncludeSelections, having type bool + ParameterId["ShowIncludeSelections"] = "showIncludeSelections"; + // DPI_ShowIncrSchedules, having type bool + ParameterId["ShowIncrSchedules"] = "showIncrSchedules"; + // DPI_ShowInnerMostLevel, having type bool + ParameterId["ShowInnerMostLevel"] = "showInnermostLevel"; + // DPI_ShowItalics, having type bool + ParameterId["ShowItalics"] = "showItalicsOption"; + // DPI_ShowLegend, having type bool + ParameterId["ShowLegend"] = "showLegend"; + // DPI_ShowLockedPermissionsIcon, having type bool + ParameterId["ShowLockedPermissionsIcon"] = "showLockedPermissionsIcon"; + // DPI_ShowManageDatasources, having type bool + ParameterId["ShowManageDatasources"] = "showManageDatasources"; + // DPI_ShowMapLegend, having type bool + ParameterId["ShowMapLegend"] = "showMapLegend"; + // DPI_ShowMapScale, having type bool + ParameterId["ShowMapScale"] = "showMapScale"; + // DPI_ShowMappedFilterCols, having type bool + ParameterId["ShowMappedFilterCols"] = "showMappedFilterColumns"; + // DPI_ShowName, having type bool + ParameterId["ShowName"] = "showName"; + // DPI_ShowNone, having type bool + ParameterId["ShowNone"] = "showNone"; + // DPI_ShowPagePlayback, having type bool + ParameterId["ShowPagePlayback"] = "showPagePlayback"; + // DPI_ShowPageReadout, having type bool + ParameterId["ShowPageReadout"] = "showPageReadout"; + // DPI_ShowPageSlider, having type bool + ParameterId["ShowPageSlider"] = "showPageSlider"; + // DPI_ShowParent, having type bool + ParameterId["ShowParent"] = "showParent"; + // DPI_ShowPercentages, having type bool + ParameterId["ShowPercentages"] = "showPercentages"; + // DPI_ShowPredictionIntervals, having type bool + ParameterId["ShowPredictionIntervals"] = "showPredictionIntervals"; + // DPI_ShowPublishedDatasources, having type bool + ParameterId["ShowPublishedDatasources"] = "showPublishedDatasources"; + // DPI_ShowRelDatePicker, having type bool + ParameterId["ShowRelDatePicker"] = "showRelDatePicker"; + // DPI_ShowReplaceDatasource, having type bool + ParameterId["ShowReplaceDatasource"] = "showReplaceDatasource"; + // DPI_ShowSeparator, having type bool + ParameterId["ShowSeparator"] = "showSeparator"; + // DPI_ShowShapeLegend, having type bool + ParameterId["ShowShapeLegend"] = "showShapeLegend"; + // DPI_ShowSizeLegend, having type bool + ParameterId["ShowSizeLegend"] = "showSizeLegend"; + // DPI_ShowShelf, having type bool + ParameterId["ShowShelf"] = "showShelf"; + // DPI_ShowStructure, having type bool + ParameterId["ShowStructure"] = "showStructure"; + // DPI_ShowSyncClientOptions, having type bool + ParameterId["ShowSyncClientOptions"] = "showSyncClientOptions"; + // DPI_ShowTabsAllowed, having type bool + ParameterId["ShowTabsAllowed"] = "showTabsAllowed"; + // DPI_ShowTime, having type bool + ParameterId["ShowTime"] = "showTime"; + // DPI_ShowTitle, having type bool + ParameterId["ShowTitle"] = "showTitle"; + // DPI_ShowTransSlider, having type bool + ParameterId["ShowTransSlider"] = "showTransparencySlider"; + // DPI_ShowUnderline, having type bool + ParameterId["ShowUnderline"] = "showUnderlineOption"; + // DPI_ShowUserThumbnailOptions, having type bool + ParameterId["ShowUserThumbnailOptions"] = "showUserThumbnailOptions"; + // DPI_ShowView, having type bool + ParameterId["ShowView"] = "showView"; + // DPI_ShowViews, having type bool + ParameterId["ShowViews"] = "showViews"; + // DPI_ShowingPageLoadError, having type bool + ParameterId["ShowingPageLoadError"] = "showingPageLoadError"; + // DPI_SupressAliases, having type bool + ParameterId["SupressAliases"] = "suspressAliases"; + // DPI_SupressThousandsSeparator, having type bool + ParameterId["SupressThousandsSeparator"] = "supressThousandsSeparator"; + // DPI_SingleSelectOnly, having type bool + ParameterId["SingleSelectOnly"] = "singleSelectOnly"; + // DPI_SkipIfActive, having type bool + ParameterId["SkipIfActive"] = "skipIfActive"; + // DPI_SkipRefresh, having type bool + ParameterId["SkipRefresh"] = "skipRefresh"; + // DPI_SkipValidation, having type bool + ParameterId["SkipValidation"] = "skipValidation"; + // DPI_Skipped, having type bool + ParameterId["Skipped"] = "skipped"; + // DPI_SortFieldIsInvalid, having type bool + ParameterId["SortFieldIsInvalid"] = "sortFieldIsInvalid"; + // DPI_SortModeIsAuto, having type bool + ParameterId["SortModeIsAuto"] = "sortModeIsAuto"; + // DPI_SplitOnEdgeSnap, having type bool + ParameterId["SplitOnEdgeSnap"] = "splitOnEdgeSnap"; + // DPI_StandardDeviationAllowed, having type bool + ParameterId["StandardDeviationAllowed"] = "standardDeviationAllowed"; + // DPI_State, having type bool + ParameterId["State"] = "state"; + // DPI_StoredProcDisabled, having type bool + ParameterId["StoredProcDisabled"] = "storedProcDisabled"; + // DPI_StoredProcsDropable, having type bool + ParameterId["StoredProcsDropable"] = "storedProcsDropable"; + // DPI_StoryIsEmpty, having type bool + ParameterId["StoryIsEmpty"] = "storyIsEmpty"; + // DPI_StoryPointIsEmpty, having type bool + ParameterId["StoryPointIsEmpty"] = "storyPointIsEmpty"; + // DPI_SuccessfulSave, having type bool + ParameterId["SuccessfulSave"] = "successfulSave"; + // DPI_SupportXAxis, having type bool + ParameterId["SupportXAxis"] = "supportXAxis"; + // DPI_SupportYAxis, having type bool + ParameterId["SupportYAxis"] = "supportYAxis"; + // DPI_SupportsCenterAlignment, having type bool + ParameterId["SupportsCenterAlignment"] = "supportsCenterAlignment"; + // DPI_SupportsDBFilters, having type bool + ParameterId["SupportsDBFilters"] = "supportsDatabaseFilters"; + // DPI_SupportsMultipleValues, having type bool + ParameterId["SupportsMultipleValues"] = "supportsMultipleValues"; + // DPI_SupportsRightAlignment, having type bool + ParameterId["SupportsRightAlignment"] = "supportsRightAlignment"; + // DPI_SupportsTableFilters, having type bool + ParameterId["SupportsTableFilters"] = "supportsTableFilters"; + // DPI_Symmetric, having type bool + ParameterId["Symmetric"] = "symmetric"; + // DPI_SyncAutomaticDrill, having type bool + ParameterId["SyncAutomaticDrill"] = "syncAutomaticDrill"; + // DPI_TabsAllowed, having type bool + ParameterId["TabsAllowed"] = "tabsAllowed"; + // DPI_TextDropdownState, having type bool + ParameterId["TextDropdownState"] = "toggleState"; + // DPI_TitleInline, having type bool + ParameterId["TitleInline"] = "titleInline"; + // DPI_ToggleHighlightStateChanged, having type bool + ParameterId["ToggleHighlightStateChanged"] = "toggleHighlight"; + // DPI_Transformed80Format, having type bool + ParameterId["Transformed80Format"] = "oldFormat"; + // DPI_TrendLineSelected, having type bool + ParameterId["TrendLineSelected"] = "trendLineSelected"; + // DPI_TruncDate, having type bool + ParameterId["TruncDate"] = "truncDate"; + // DPI_TupleSelected, having type bool + ParameterId["TupleSelected"] = "tupleSelected"; + // DPI_UIAutomationDidPageLoad, having type bool + ParameterId["UIAutomationDidPageLoad"] = "uiAutomationDidPageLoad"; + // DPI_UIAutomationIsChecked, having type bool + ParameterId["UIAutomationIsChecked"] = "uiAutomationIsChecked"; + // DPI_UIAutomationIsEnabled, having type bool + ParameterId["UIAutomationIsEnabled"] = "uiAutomationIsEnabled"; + // DPI_UIAutomationIsEventProcessed, having type bool + ParameterId["UIAutomationIsEventProcessed"] = "uiAutomationIsEventProcessed"; + // DPI_UIAutomationIsFocused, having type bool + ParameterId["UIAutomationIsFocused"] = "uiAutomationIsFocused"; + // DPI_UIAutomationIsFound, having type bool + ParameterId["UIAutomationIsFound"] = "uiAutomationIsFound"; + // DPI_UIAutomationIsReadonly, having type bool + ParameterId["UIAutomationIsReadonly"] = "uiAutomationIsReadonly"; + // DPI_UIAutomationIsSelected, having type bool + ParameterId["UIAutomationIsSelected"] = "uiAutomationIsSelected"; + // DPI_UpdateAllPanes, having type bool + ParameterId["UpdateAllPanes"] = "updateAllPanes"; + // DPI_UpdateDSCaptionOnly, having type bool + ParameterId["UpdateDSCaptionOnly"] = "updateDsCaptionOnly"; + // DPI_UpdateModelFromParams, having type bool + ParameterId["UpdateModelFromParams"] = "updateModelFromParams"; + // DPI_UpdateShelves, having type bool + ParameterId["UpdateShelves"] = "updateShelves"; + // DPI_UpdatesUseContext, having type bool + ParameterId["UpdatesUseContext"] = "updatesUseContext"; + // DPI_UpgradeDocumentVersion, having type bool + ParameterId["UpgradeDocumentVersion"] = "upgradeDocumentVersion"; + // DPI_UseAliases, having type bool + ParameterId["UseAliases"] = "useAliases"; + // DPI_UseBlankForNull, having type bool + ParameterId["UseBlankForNull"] = "useBlankForNull"; + // DPI_UseCalculationEditor, having type bool + ParameterId["UseCalculationEditor"] = "useCalculationEditor"; + // DPI_UseCenterValue, having type bool + ParameterId["UseCenterValue"] = "useCenterValue"; + // DPI_UseColor, having type bool + ParameterId["UseColor"] = "useColor"; + // DPI_UseCustomMarkSize, having type bool + ParameterId["UseCustomMarkSize"] = "useCustomMarkSize"; + // DPI_UseDarkIcons, having type bool + ParameterId["UseDarkIcons"] = "useDarkIcons"; + // DPI_UseDataStoreMinfiedNames, having type bool + ParameterId["UseDataStoreMinfiedNames"] = "useDatastoreMinNames"; + // DPI_UseInitialDomainType, having type bool + ParameterId["UseInitialDomainType"] = "useInitialDomainType"; + // DPI_UseEndValue, having type bool + ParameterId["UseEndValue"] = "useEndValue"; + // DPI_UseForOverlayHitTest, having type bool + ParameterId["UseForOverlayHitTest"] = "useForOverlayHitTest"; + // DPI_UseFullColorRange, having type bool + ParameterId["UseFullColorRange"] = "useFullColorRange"; + // DPI_UseFullDomain, having type bool + ParameterId["UseFullDomain"] = "useFullDomain"; + // DPI_UseInlineImages, having type bool + ParameterId["UseInlineImages"] = "useInlineImages"; + // DPI_UseMeasures, having type bool + ParameterId["UseMeasures"] = "useMeasures"; + // DPI_UseNewQuickFilters, having type bool + ParameterId["UseNewQuickFilters"] = "useNewQuickFilters"; + // DPI_UseNotificationReturn, having type bool + ParameterId["UseNotificationReturn"] = "useNotificationReturn"; + // DPI_UseParameters, having type bool + ParameterId["UseParameters"] = "useParameters"; + // DPI_UseSelector, having type bool + ParameterId["UseSelector"] = "useSelector"; + // DPI_UseSignificantDigits, having type bool + ParameterId["UseSignificantDigits"] = "useSignificantDigits"; + // DPI_UseSpecialStrings, having type bool + ParameterId["UseSpecialStrings"] = "useSpecialStrings"; + // DPI_UseStartValue, having type bool + ParameterId["UseStartValue"] = "useStartValue"; + // DPI_UseTabs, having type bool + ParameterId["UseTabs"] = "useTabs"; + // DPI_UseTabletAsDefaultPreview, having type bool + ParameterId["UseTabletAsDefaultPreview"] = "useTabletAsDefaultPreview"; + // DPI_UseTargetPt, having type bool + ParameterId["UseTargetPt"] = "useTargetPoint"; + // DPI_UseUSLocale, having type bool + ParameterId["UseUSLocale"] = "useUsLocale"; + // DPI_UseYAxis, having type bool + ParameterId["UseYAxis"] = "useYAxis"; + // DPI_Valid, having type bool + ParameterId["Valid"] = "valid"; + // DPI_VizDataV82, having type bool + ParameterId["VizDataV82"] = "vizData82"; + // DPI_WMSConnectionSuccessful, having type bool + ParameterId["WMSConnectionSuccessful"] = "wmsConnectionSuccessful"; + // DPI_WMSShouldUseTiles, having type bool + ParameterId["WMSShouldUseTiles"] = "wmsShouldUseTiles"; + // DPI_WantDomain, having type bool + ParameterId["WantDomain"] = "wantDomain"; + // DPI_WorkbookModified, having type bool + ParameterId["WorkbookModified"] = "workbookModified"; + // DPI_ZoomIn, having type bool + ParameterId["ZoomIn"] = "zoomIn"; + // DPI_ShowMarkLabels, having type bool + ParameterId["ShowMarkLabels"] = "showMarkLabels"; + // DPI_HasDuplicates, having type bool + ParameterId["HasDuplicates"] = "hasDuplicates"; + // DPI_HasUserDefinedIncrement, having type bool + ParameterId["HasUserDefinedIncrement"] = "hasUserDefinedIncrement"; + // DPI_HasUserDefinedMax, having type bool + ParameterId["HasUserDefinedMax"] = "hasUserDefinedMax"; + // DPI_HasUserDefinedMin, having type bool + ParameterId["HasUserDefinedMin"] = "hasUserDefinedMin"; + // DPI_IsDuplicate, having type bool + ParameterId["IsDuplicate"] = "isDuplicate"; + // DPI_IsEditingValue, having type bool + ParameterId["IsEditingValue"] = "isEditingValue"; + // DPI_ShouldRestrictDataType, having type bool + ParameterId["ShouldRestrictDataType"] = "restrictDataType"; + // DPI_EnableIncludeZero, having type bool + ParameterId["EnableIncludeZero"] = "enableIncludeZero"; + // DPI_EnableSyncDualAxes, having type bool + ParameterId["EnableSyncDualAxes"] = "enableSynchronizeDualAxes"; + // DPI_EnableShowTimes, having type bool + ParameterId["EnableShowTimes"] = "enableShowTimes"; + // DPI_EnableTickMarksTab, having type bool + ParameterId["EnableTickMarksTab"] = "enableTickMarksTab"; + // DPI_IsTemporal, having type bool + ParameterId["IsTemporal"] = "isTemporal"; + // DPI_ShouldIncludeZero, having type bool + ParameterId["ShouldIncludeZero"] = "shouldIncludeZero"; + // DPI_ShouldReverseAxis, having type bool + ParameterId["ShouldReverseAxis"] = "shouldReverseAxis"; + // DPI_ShouldShowTimes, having type bool + ParameterId["ShouldShowTimes"] = "shouldShowTimes"; + // DPI_UseAutomaticAxisSubtitle, having type bool + ParameterId["UseAutomaticAxisSubtitle"] = "useAutomaticSubtitle"; + // DPI_UseAutomaticAxisTitle, having type bool + ParameterId["UseAutomaticAxisTitle"] = "useAutomaticTitle"; + // DPI_AllSelected, having type bool + ParameterId["AllSelected"] = "allSelected"; + // DPI_AutoCommit, having type bool + ParameterId["AutoCommit"] = "autoCommit"; + // DPI_CacheOnly, having type bool + ParameterId["CacheOnly"] = "cacheOnly"; + // DPI_IncludeData, having type bool + ParameterId["IncludeData"] = "includeData"; + // DPI_IsPatternExclusive, having type bool + ParameterId["IsPatternExclusive"] = "isPatternExclusive"; + // DPI_IsSearchable, having type bool + ParameterId["IsSearchable"] = "isSearchable"; + // DPI_IsSelectionExclusive, having type bool + ParameterId["IsSelectionExclusive"] = "isSelectionExclusive"; + // DPI_ResetNewFilter, having type bool + ParameterId["ResetNewFilter"] = "resetNewFilter"; + // DPI_UseAllWhenManualEmpty, having type bool + ParameterId["UseAllWhenManualEmpty"] = "useAllWhenManualEmpty"; + // DPI_UseAllWhenPatternEmpty, having type bool + ParameterId["UseAllWhenPatternEmpty"] = "useAllWhenPatternEmpty"; + // DPI_GroupByDrillDown, having type bool + ParameterId["GroupByDrillDown"] = "groupByDrillDown"; + // DPI_GroupByTable, having type bool + ParameterId["GroupByTable"] = "groupByTable"; + // DPI_IncludeGroups, having type bool + ParameterId["IncludeGroups"] = "includeGroups"; + // DPI_IncludePendingState, having type bool + ParameterId["IncludePendingState"] = "includePendingState"; + // DPI_IncludeFieldMenus, having type bool + ParameterId["IncludeFieldMenus"] = "includeFieldMenus"; + // DPI_IncludeFormattedValues, having type bool + ParameterId["IncludeFormattedValues"] = "includeFormattedValues"; + // DPI_IncludeColumnInstances, having type bool + ParameterId["IncludeColumnInstances"] = "includeColumnInstances"; + // DPI_IncludeAdHocCalcs, having type bool + ParameterId["IncludeAdHocCalcs"] = "includeAdhocCalcs"; + // DPI_IncludeHiddenInvalidFields, having type bool + ParameterId["IncludeHiddenInvalidFields"] = "includeHiddenInvalidFields"; + // DPI_IncludeNonExtractedColumns, having type bool + ParameterId["IncludeNonExtractedColumns"] = "includeNonExtractedColumns"; + // DPI_IncludeCalculatedFieldFormulas, having type bool + ParameterId["IncludeCalculatedFieldFormulas"] = "includeCalculatedFieldFormulas"; + // DPI_SetDataPreviewCustomFieldOrder, having type bool + ParameterId["SetDataPreviewCustomFieldOrder"] = "setDataPreviewCustomFieldOrder"; + // DPI_CustomSplitAllowSplitFromRight, having type bool + ParameterId["CustomSplitAllowSplitFromRight"] = "customSplitAllowSplitFromRight"; + // DPI_IsChanged, having type bool + ParameterId["IsChanged"] = "isChanged"; + // DPI_ShowFontColorPicker, having type bool + ParameterId["ShowFontColorPicker"] = "showFontColorPicker"; + // DPI_ShowFontFamilyPicker, having type bool + ParameterId["ShowFontFamilyPicker"] = "showFontFamilyPicker"; + // DPI_ShowFontSizePicker, having type bool + ParameterId["ShowFontSizePicker"] = "showFontSizePicker"; + // DPI_ShowFontStyleButtons, having type bool + ParameterId["ShowFontStyleButtons"] = "showFontStyleButtons"; + // DPI_ShowLineForAll, having type bool + ParameterId["ShowLineForAll"] = "showLineForAll"; + // DPI_ShowLineForColumn, having type bool + ParameterId["ShowLineForColumn"] = "showLineForColumn"; + // DPI_ShowLineForRow, having type bool + ParameterId["ShowLineForRow"] = "showLineForRow"; + // DPI_ShowLinePatternPicker, having type bool + ParameterId["ShowLinePatternPicker"] = "showLinePatternPicker"; + // DPI_ShowLineTransparency, having type bool + ParameterId["ShowLineTransparency"] = "showLineTransparency"; + // DPI_ShowLineWidthPicker, having type bool + ParameterId["ShowLineWidthPicker"] = "showLineWidthPicker"; + // DPI_CanBeAuto, having type bool + ParameterId["CanBeAuto"] = "canBeAuto"; + // DPI_CanBeNone, having type bool + ParameterId["CanBeNone"] = "canBeNone"; + // DPI_CanMatchMarkColor, having type bool + ParameterId["CanMatchMarkColor"] = "canMatchMarkColor"; + // DPI_HasOpacity, having type bool + ParameterId["HasOpacity"] = "hasOpacity"; + // DPI_IncludeAllHidden, having type bool + ParameterId["IncludeAllHidden"] = "includeAllHidden"; + // DPI_IncludeCurrent, having type bool + ParameterId["IncludeCurrent"] = "includeCurrent"; + // DPI_IsIncluded, having type bool + ParameterId["IsIncluded"] = "isIncluded"; + // DPI_IsRelative, having type bool + ParameterId["IsRelative"] = "isRelative"; + // DPI_IsSecondaryAllowed, having type bool + ParameterId["IsSecondaryAllowed"] = "isSecondaryAllowed"; + // DPI_NullIfIncomplete, having type bool + ParameterId["NullIfIncomplete"] = "nullIfIncomplete"; + // DPI_IsCalcAssistanceEnabled, having type bool + ParameterId["IsCalcAssistanceEnabled"] = "isCalcAssistanceEnabled"; + // DPI_UseSecondaryCalc, having type bool + ParameterId["UseSecondaryCalc"] = "useSecondaryCalc"; + // DPI_CanLoad, having type bool + ParameterId["CanLoad"] = "canLoad"; + // DPI_DescriptionOnly, having type bool + ParameterId["DescriptionOnly"] = "descriptionOnly"; + // DPI_AreAliasesSupported, having type bool + ParameterId["AreAliasesSupported"] = "areAliasesSupported"; + // DPI_AreRefColumnsSupported, having type bool + ParameterId["AreRefColumnsSupported"] = "areRefColumnsSupported"; + // DPI_IsAggregated, having type bool + ParameterId["IsAggregated"] = "isAggregated"; + // DPI_IsExportSupported, having type bool + ParameterId["IsExportSupported"] = "isExportSupported"; + // DPI_IsMeasureNames, having type bool + ParameterId["IsMeasureNames"] = "isMeasureNames"; + // DPI_IsSummarySupported, having type bool + ParameterId["IsSummarySupported"] = "isSummarySupported"; + // DPI_IsTopNSupported, having type bool + ParameterId["IsTopNSupported"] = "isTopNSupported"; + // DPI_IsUnderlyingSupported, having type bool + ParameterId["IsUnderlyingSupported"] = "isUnderlyingSupported"; + // DPI_OnlyExportSummary, having type bool + ParameterId["OnlyExportSummary"] = "onlyExportSummary"; + // DPI_ShowAllFields, having type bool + ParameterId["ShowAllFields"] = "showAllFields"; + // DPI_UseTablePtrs, having type bool + ParameterId["UseTablePtrs"] = "useTablePtrs"; + // DPI_OnlyFetchSummary, having type bool + ParameterId["OnlyFetchSummary"] = "onlyFetchSummary"; + // DPI_IsDeviceLayoutCustomized, having type bool + ParameterId["IsDeviceLayoutCustomized"] = "isDeviceLayoutCustomized"; + // DPI_IsDeviceSizeCustomized, having type bool + ParameterId["IsDeviceSizeCustomized"] = "isDeviceSizeCustomized"; + // DPI_IsDeviceSupportedByMobileApp, having type bool + ParameterId["IsDeviceSupportedByMobileApp"] = "isDeviceSupportedByMobileApp"; + // DPI_IsPortrait, having type bool + ParameterId["IsPortrait"] = "isPortrait"; + // DPI_IsPortraitByDefault, having type bool + ParameterId["IsPortraitByDefault"] = "isPortraitByDefault"; + // DPI_IsUserCustomFormat, having type bool + ParameterId["IsUserCustomFormat"] = "isUserCustomFormat"; + // DPI_ShouldDisplayRebuildExtractMessage, having type bool + ParameterId["ShouldDisplayRebuildExtractMessage"] = "shouldDisplayRebuildExtractMessage"; + // DPI_SupportsCustomStartOfWeek, having type bool + ParameterId["SupportsCustomStartOfWeek"] = "supportsCustomStartOfWeek"; + // DPI_NeedsConnectPrompt, having type bool + ParameterId["NeedsConnectPrompt"] = "needsConnectPrompt"; + // DPI_NeedsCloseDataSourceErrorPrompt, having type bool + ParameterId["NeedsCloseDataSourceErrorPrompt"] = "needsCloseDsErrorPrompt"; + // DPI_ClearCurrentSelection, having type bool + ParameterId["ClearCurrentSelection"] = "clearCurrentSelection"; + // DPI_HasContains, having type bool + ParameterId["HasContains"] = "hasContains"; + // DPI_HasEndsWith, having type bool + ParameterId["HasEndsWith"] = "hasEndsWith"; + // DPI_HasReplaceSelection, having type bool + ParameterId["HasReplaceSelection"] = "hasReplaceSelection"; + // DPI_HasStartsWith, having type bool + ParameterId["HasStartsWith"] = "hasStartsWith"; + // DPI_IsLeafSelectionOnly, having type bool + ParameterId["IsLeafSelectionOnly"] = "isLeafSelectionOnly"; + // DPI_ReplaceSelection, having type bool + ParameterId["ReplaceSelection"] = "replaceSelection"; + // DPI_IsColorPaletteCustomized, having type bool + ParameterId["IsColorPaletteCustomized"] = "isColorPaletteCustomized"; + // DPI_ReversePaletteOrder, having type bool + ParameterId["ReversePaletteOrder"] = "reversePaletteOrder"; + // DPI_TriedToConnect, having type bool + ParameterId["TriedToConnect"] = "triedToConnect"; + // DPI_ScaleMarksInAxisUnits, having type bool + ParameterId["ScaleMarksInAxisUnits"] = "scaleMarksInAxisUnits"; + // DPI_ShowMarkSizingOptions, having type bool + ParameterId["ShowMarkSizingOptions"] = "showMarkSizingOptions"; + // DPI_UseSizeFieldCaption, having type bool + ParameterId["UseSizeFieldCaption"] = "useSizeFieldCaption"; + // DPI_IsLicensedAndRegistered, having type bool + ParameterId["IsLicensedAndRegistered"] = "isLicensedAndRegistered"; + // DPI_SetNewDatasourceActive, having type bool + ParameterId["SetNewDatasourceActive"] = "setNewDatasourceActive"; + // DPI_AllowCustomLabel, having type bool + ParameterId["AllowCustomLabel"] = "allowCustomLabel"; + // DPI_IsMostRecentModeValid, having type bool + ParameterId["IsMostRecentModeValid"] = "isMostRecentModeValid"; + // DPI_MustShowLabels, having type bool + ParameterId["MustShowLabels"] = "mustShowLabels"; + // DPI_ShowRunningOrderLabels, having type bool + ParameterId["ShowRunningOrderLabels"] = "showRunningOrderLabels"; + // DPI_IsDroppedFile, having type bool + ParameterId["IsDroppedFile"] = "isDroppedFile"; + // DPI_IsInitialized, having type bool + ParameterId["IsInitialized"] = "isInitialized"; + // DPI_IncludeDashboard, having type bool + ParameterId["IncludeDashboard"] = "includeDashboard"; + // DPI_ChildrenCanResize, having type bool + ParameterId["ChildrenCanResize"] = "childrenCanResize"; + // DPI_BoolMap, having type Dictionary(of bool) + ParameterId["BoolMap"] = "boolMap"; + // DPI_CheckedMenuItems, having type bool[] + ParameterId["CheckedMenuItems"] = "checkedMenuItems"; + // DPI_IncludedSheetValues, having type bool[] + ParameterId["IncludedSheetValues"] = "includedSheetValues"; + // DPI_SortOrderVector, having type bool[] + ParameterId["SortOrderVector"] = "sortOrderVector"; + // DPI_ActionName, having type string + ParameterId["ActionName"] = "actionName"; + // DPI_ActionSourceText, having type string + ParameterId["ActionSourceText"] = "actionSourceText"; + // DPI_ActionTypeAsString, having type string + ParameterId["ActionTypeAsString"] = "actionTypeAsString"; + // DPI_ActiveTab, having type string + ParameterId["ActiveTab"] = "active_tab"; + // DPI_AddInFeatureName, having type string + ParameterId["AddInFeatureName"] = "addInFeatureName"; + // DPI_AddInId, having type string + ParameterId["AddInId"] = "addInId"; + // DPI_AddInstanceId, having type string + ParameterId["AddInstanceId"] = "addInInstanceId"; + // DPI_AddInName, having type string + ParameterId["AddInName"] = "addInName"; + // DPI_AddInLocale, having type string + ParameterId["AddInLocale"] = "addInLocale"; + // DPI_AddInLanguage, having type string + ParameterId["AddInLanguage"] = "addInLanguage"; + // DPI_APIVersion, having type string + ParameterId["APIVersion"] = "apiVersion"; + // DPI_Alias, having type string + ParameterId["Alias"] = "alias"; + // DPI_AnchorDate, having type string + ParameterId["AnchorDate"] = "anchorDate"; + // DPI_AnnotationRes, having type string + ParameterId["AnnotationRes"] = "annotationRes"; + // DPI_ReadId, having type string + ParameterId["ReadId"] = "readId"; + // DPI_AnnotationText, having type string + ParameterId["AnnotationText"] = "annotationText"; + // DPI_ArchiveDirectory, having type string + ParameterId["ArchiveDirectory"] = "archiveDirectory"; + // DPI_ArchiveFullPath, having type string + ParameterId["ArchiveFullPath"] = "archiveFullPath"; + // DPI_AtTheLevelInvalidFieldCaption, having type string + ParameterId["AtTheLevelInvalidFieldCaption"] = "atTheLevelInvalidFieldCaption"; + // DPI_AutoCompleteSubstring, having type string + ParameterId["AutoCompleteSubstring"] = "acSubstring"; + // DPI_AutosaveFileId, having type string + ParameterId["AutosaveFileId"] = "autosaveFileId"; + // DPI_AutosaveTimerInterval, having type string + ParameterId["AutosaveTimerInterval"] = "autosaveTimerInterval"; + // DPI_BaseColumnCaption, having type string + ParameterId["BaseColumnCaption"] = "baseColumnCaption"; + // DPI_ButtonObjectClickAction, having type string + ParameterId["ButtonObjectClickAction"] = "buttonObjectClickAction"; + // DPI_ButtonObjectImagePath, having type string + ParameterId["ButtonObjectImagePath"] = "buttonObjectImagePath"; + // DPI_ClearButtonText, having type string + ParameterId["ClearButtonText"] = "clearButtonText"; + // DPI_ColorPaletteId, having type string + ParameterId["ColorPaletteId"] = "colorPaletteId"; + // DPI_ColorPaletteName, having type string + ParameterId["ColorPaletteName"] = "colorPaletteName"; + // DPI_ColorSwatch, having type string + ParameterId["ColorSwatch"] = "colorSwatch"; + // DPI_CommandName, having type string + ParameterId["CommandName"] = "commandName"; + // DPI_ConfidenceLevelValue, having type string + ParameterId["ConfidenceLevelValue"] = "confidenceLevelValue"; + // DPI_CountDistinctStr, having type string + ParameterId["CountDistinctStr"] = "countDistinctStr"; + // DPI_CrossTabFilepath, having type string + ParameterId["CrossTabFilepath"] = "crossTabFilepath"; + // DPI_CSSMargin, having type string + ParameterId["CSSMargin"] = "cssMargin"; + // DPI_CSSWhitespace, having type string + ParameterId["CSSWhitespace"] = "cssWhitespace"; + // DPI_DBPassword, having type string + ParameterId["DBPassword"] = "dbPassword"; + // DPI_DBUsername, having type string + ParameterId["DBUsername"] = "dbUsername"; + // DPI_DataAlertConditionText, having type string + ParameterId["DataAlertConditionText"] = "dataAlertConditionText"; + // DPI_DataAlertMeasureText, having type string + ParameterId["DataAlertMeasureText"] = "dataAlertMeasureText"; + // DPI_DataAlertSpecSerializedText, having type string + ParameterId["DataAlertSpecSerializedText"] = "dataAlertSpecSerializedText"; + // DPI_DataAlertDefaultSubject, having type string + ParameterId["DataAlertDefaultSubject"] = "dataAlertDefaultSubject"; + // DPI_DataAlertThresholdText, having type string + ParameterId["DataAlertThresholdText"] = "dataAlertThresholdText"; + // DPI_DataGridSortColumnName, having type string + ParameterId["DataGridSortColumnName"] = "datagridSortColumnName"; + // DPI_DataServerConnectionError, having type string + ParameterId["DataServerConnectionError"] = "dataServerConnectionError"; + // DPI_DatabaseFilter, having type string + ParameterId["DatabaseFilter"] = "databaseFilter"; + // DPI_DatabaseFilterPrompt, having type string + ParameterId["DatabaseFilterPrompt"] = "databaseFilterPrompt"; + // DPI_DatasourceRanking, having type string + ParameterId["DatasourceRanking"] = "datasourceRanking"; + // DPI_DatasourceUrl, having type string + ParameterId["DatasourceUrl"] = "datasourceUrl"; + // DPI_DatasourceUsername, having type string + ParameterId["DatasourceUsername"] = "datasourceUsername"; + // DPI_DateFormat, having type string + ParameterId["DateFormat"] = "dateFormat"; + // DPI_DatePart, having type string + ParameterId["DatePart"] = "datePart"; + // DPI_DatePartAbbrev, having type string + ParameterId["DatePartAbbrev"] = "datePartAbbrev"; + // DPI_DefaultHierarchyName, having type string + ParameterId["DefaultHierarchyName"] = "defaultHierarchyName"; + // DPI_DefaultMenuItemKey, having type string + ParameterId["DefaultMenuItemKey"] = "defaultMenuItemKey"; + // DPI_Delimiter, having type string + ParameterId["Delimiter"] = "delimiter"; + // DPI_DeviceName, having type string + ParameterId["DeviceName"] = "deviceName"; + // DPI_DeviceType, having type string + ParameterId["DeviceType"] = "deviceType"; + // DPI_DisplayPath, having type string + ParameterId["DisplayPath"] = "displayPath"; + // DPI_DistributionValueString, having type string + ParameterId["DistributionValueString"] = "distributionValueString"; + // DPI_DrillPathName, having type string + ParameterId["DrillPathName"] = "drillPathName"; + // DPI_EmbeddedTitle, having type string + ParameterId["EmbeddedTitle"] = "embeddedTitle"; + // DPI_EnterValueText, having type string + ParameterId["EnterValueText"] = "enterValueText"; + // DPI_EscapeString, having type string + ParameterId["EscapeString"] = "escapeString"; + // DPI_ExtSvcConfigHost, having type string + ParameterId["ExtSvcConfigHost"] = "extSvcConfigHost"; + // DPI_ExtSvcConfigPassword, having type string + ParameterId["ExtSvcConfigPassword"] = "extSvcConfigPassword"; + // DPI_ExtSvcConfigPort, having type string + ParameterId["ExtSvcConfigPort"] = "extSvcConfigPort"; + // DPI_ExtSvcConfigConnectTimeout, having type string + ParameterId["ExtSvcConfigConnectTimeout"] = "extSvcConnectTimeout"; + // DPI_ExtSvcConfigPrevHost, having type string + ParameterId["ExtSvcConfigPrevHost"] = "extSvcConfigPrevHost"; + // DPI_ExtSvcConfigUsername, having type string + ParameterId["ExtSvcConfigUsername"] = "extSvcConfigUsername"; + // DPI_ExtractUpdateTime, having type string + ParameterId["ExtractUpdateTime"] = "extractUpdateTime"; + // DPI_FieldFolderName, having type string + ParameterId["FieldFolderName"] = "fieldFolderName"; + // DPI_FieldNameString, having type string + ParameterId["FieldNameString"] = "fieldName"; + // DPI_FilterSearchDomain, having type string + ParameterId["FilterSearchDomain"] = "filterSearchDomain"; + // DPI_FilterSpec, having type string + ParameterId["FilterSpec"] = "filterSpec"; + // DPI_FirstValue, having type string + ParameterId["FirstValue"] = "firstValue"; + // DPI_FolderName, having type string + ParameterId["FolderName"] = "folderName"; + // DPI_FontName, having type string + ParameterId["FontName"] = "fontName"; + // DPI_FormatString, having type string + ParameterId["FormatString"] = "formatString"; + // DPI_FormattedDisplayString, having type string + ParameterId["FormattedDisplayString"] = "formattedDisplayString"; + // DPI_FormattedIncrementValue, having type string + ParameterId["FormattedIncrementValue"] = "formattedIncrement"; + // DPI_FormattedMaxValue, having type string + ParameterId["FormattedMaxValue"] = "formattedMax"; + // DPI_FormattedMinValue, having type string + ParameterId["FormattedMinValue"] = "formattedMin"; + // DPI_FormattedValue, having type string + ParameterId["FormattedValue"] = "formattedValue"; + // DPI_FormattedCenterValue, having type string + ParameterId["FormattedCenterValue"] = "formattedCenter"; + // DPI_FormattedEndValue, having type string + ParameterId["FormattedEndValue"] = "formattedEnd"; + // DPI_FormattedStartValue, having type string + ParameterId["FormattedStartValue"] = "formattedStart"; + // DPI_PairedFormattedValue, having type string + ParameterId["PairedFormattedValue"] = "pairedFormattedValue"; + // DPI_FrameAttributes, having type string + ParameterId["FrameAttributes"] = "frameAttr"; + // DPI_GUID, having type string + ParameterId["GUID"] = "guid"; + // DPI_GeographicSearchCandidateDisplayName, having type string + ParameterId["GeographicSearchCandidateDisplayName"] = "geographicSearchCandidateDisplayName"; + // DPI_GeographicSearchCandidateParentName, having type string + ParameterId["GeographicSearchCandidateParentName"] = "geographicSearchCandidateParentName"; + // DPI_GeographicSearchCandidateType, having type string + ParameterId["GeographicSearchCandidateType"] = "geographicSearchCandidateType"; + // DPI_GeographicSearchLocale, having type string + ParameterId["GeographicSearchLocale"] = "geographicSearchLocale"; + // DPI_GeographicSearchQueryString, having type string + ParameterId["GeographicSearchQueryString"] = "geographicSearchSearchString"; + // DPI_GeographicSearchUILocale, having type string + ParameterId["GeographicSearchUILocale"] = "geographicSearchUilocale"; + // DPI_IconRes, having type string + ParameterId["IconRes"] = "iconRes"; + // DPI_ImageHash, having type string + ParameterId["ImageHash"] = "imageHash"; + // DPI_ImageName, having type string + ParameterId["ImageName"] = "imageName"; + // DPI_ImageRes, having type string + ParameterId["ImageRes"] = "imageRes"; + // DPI_IncludesSiblingsPrompt, having type string + ParameterId["IncludesSiblingsPrompt"] = "includesSiblingsPrompt"; + // DPI_IncludesSubfoldersPrompt, having type string + ParameterId["IncludesSubfoldersPrompt"] = "includesSubfoldersPrompt"; + // DPI_IncrementalScheduleIDs, having type string + ParameterId["IncrementalScheduleIDs"] = "incrementalScheduleIds"; + // DPI_InvariantKeyword, having type string + ParameterId["InvariantKeyword"] = "invariantKeyword"; + // DPI_JoinOperator, having type string + ParameterId["JoinOperator"] = "joinOperator"; + // DPI_JoinExpression, having type string + ParameterId["JoinExpression"] = "joinExpression"; + // DPI_Key, having type string + ParameterId["Key"] = "keyId"; + // DPI_Label, having type string + ParameterId["Label"] = "label"; + // DPI_PairedLabel, having type string + ParameterId["PairedLabel"] = "pairedLabel"; + // DPI_LayoutID, having type string + ParameterId["LayoutID"] = "layoutId"; + // DPI_LeftJoinExpression, having type string + ParameterId["LeftJoinExpression"] = "leftJoinExpression"; + // DPI_LimitCountExpression, having type string + ParameterId["LimitCountExpression"] = "limitCountExpression"; + // DPI_LinkTarget, having type string + ParameterId["LinkTarget"] = "linkTarget"; + // DPI_Locale, having type string + ParameterId["Locale"] = "locale"; + // DPI_LocalizedKeyword, having type string + ParameterId["LocalizedKeyword"] = "localizedKeyword"; + // DPI_MapBoxGLStyleId, having type string + ParameterId["MapBoxGLStyleId"] = "mapboxGlStyleId"; + // DPI_MapBoxStyleUrl, having type string + ParameterId["MapBoxStyleUrl"] = "mapboxStyleUrl"; + // DPI_MapBoxUsername, having type string + ParameterId["MapBoxUsername"] = "mapboxUsername"; + // DPI_MapScaleReadoutString, having type string + ParameterId["MapScaleReadoutString"] = "mapScaleReadoutString"; + // DPI_MapScaleTooltipString, having type string + ParameterId["MapScaleTooltipString"] = "mapScaleTooltipString"; + // DPI_MapSourceName, having type string + ParameterId["MapSourceName"] = "mapSourceName"; + // DPI_MaxLabel, having type string + ParameterId["MaxLabel"] = "maxLabel"; + // DPI_MinLabel, having type string + ParameterId["MinLabel"] = "minLabel"; + // DPI_ModelDescriptionParagraph, having type string + ParameterId["ModelDescriptionParagraph"] = "modelDescriptionParagraph"; + // DPI_NameTemplate, having type string + ParameterId["NameTemplate"] = "nameTemplate"; + // DPI_NewDrillPath, having type string + ParameterId["NewDrillPath"] = "newDrillPath"; + // DPI_NewFieldFolderName, having type string + ParameterId["NewFieldFolderName"] = "newFieldFolderName"; + // DPI_NewTableAlias, having type string + ParameterId["NewTableAlias"] = "newTableAlias"; + // DPI_NonFormattedValue, having type string + ParameterId["NonFormattedValue"] = "unformattedValue"; + // DPI_OAuthUserName, having type string + ParameterId["OAuthUserName"] = "oauthUsername"; + // DPI_ObjectName, having type string + ParameterId["ObjectName"] = "objectName"; + // DPI_ObjectOverrideMessage, having type string + ParameterId["ObjectOverrideMessage"] = "objectOverrideMessage"; + // DPI_OldTableAlias, having type string + ParameterId["OldTableAlias"] = "oldTableAlias"; + // DPI_OperatingSystem, having type string + ParameterId["OperatingSystem"] = "operatingSystem"; + // DPI_OriginalFilePath, having type string + ParameterId["OriginalFilePath"] = "originalFilePath"; + // DPI_OriginalFileVersion, having type string + ParameterId["OriginalFileVersion"] = "originalFileVersion"; + // DPI_PaneDescriptorKey, having type string + ParameterId["PaneDescriptorKey"] = "paneDescrKey"; + // DPI_ParentName, having type string + ParameterId["ParentName"] = "parentName"; + // DPI_ParentTable, having type string + ParameterId["ParentTable"] = "parentTable"; + // DPI_PatternFilterString, having type string + ParameterId["PatternFilterString"] = "patternFilterString"; + // DPI_PendingCalcName, having type string + ParameterId["PendingCalcName"] = "pendingCalcName"; + // DPI_PercentilesString, having type string + ParameterId["PercentilesString"] = "percentilesString"; + // DPI_ProjectName, having type string + ParameterId["ProjectName"] = "projectName"; + // DPI_PropertyName, having type string + ParameterId["PropertyName"] = "propertyName"; + // DPI_QuickFilterTitleCaption, having type string + ParameterId["QuickFilterTitleCaption"] = "quickFilterTitleCaption"; + // DPI_RangeDiffStr, having type string + ParameterId["RangeDiffStr"] = "diffValue"; + // DPI_RangeMaxStr, having type string + ParameterId["RangeMaxStr"] = "maxValue"; + // DPI_RangeMinStr, having type string + ParameterId["RangeMinStr"] = "minValue"; + // DPI_RecoveredFilePath, having type string + ParameterId["RecoveredFilePath"] = "recoveredFilePath"; + // DPI_ReferenceLineSpecificationId, having type string + ParameterId["ReferenceLineSpecificationId"] = "referenceLineId"; + // DPI_ReplaceFieldPrompt, having type string + ParameterId["ReplaceFieldPrompt"] = "replaceFieldPrompt"; + // DPI_RightJoinExpression, having type string + ParameterId["RightJoinExpression"] = "rightJoinExpression"; + // DPI_RootPath, having type string + ParameterId["RootPath"] = "rootPath"; + // DPI_RuntimeFinalDatastore, having type string + ParameterId["RuntimeFinalDatastore"] = "runtimeFinalDatastore"; + // DPI_RuntimeInitialDatastore, having type string + ParameterId["RuntimeInitialDatastore"] = "runtimeInitialDatastore"; + // DPI_RuntimeVTL, having type string + ParameterId["RuntimeVTL"] = "runtimeVtl"; + // DPI_SampleDataString, having type string + ParameterId["SampleDataString"] = "sampleData"; + // DPI_ScheduleIDs, having type string + ParameterId["ScheduleIDs"] = "scheduleIds"; + // DPI_SchemaFieldIconResource, having type string + ParameterId["SchemaFieldIconResource"] = "fieldIconRes"; + // DPI_ScreenName, having type string + ParameterId["ScreenName"] = "screenName"; + // DPI_ScriptCommand, having type string + ParameterId["ScriptCommand"] = "command"; + // DPI_SecondValue, having type string + ParameterId["SecondValue"] = "secondValue"; + // DPI_SelectedValue, having type string + ParameterId["SelectedValue"] = "selectedValue"; + // DPI_ShapeName, having type string + ParameterId["ShapeName"] = "shapeName"; + // DPI_SheetId, having type string + ParameterId["SheetId"] = "sheetId"; + // DPI_ShowDataTable, having type string + ParameterId["ShowDataTable"] = "showDataTable"; + // DPI_SimpleCommand, having type string + ParameterId["SimpleCommand"] = "simpleCommand"; + // DPI_SortModeCaption, having type string + ParameterId["SortModeCaption"] = "sortModeCaption"; + // DPI_SourceName, having type string + ParameterId["SourceName"] = "sourceName"; + // DPI_SourceText, having type string + ParameterId["SourceText"] = "sourceText"; + // DPI_SpecialValueText, having type string + ParameterId["SpecialValueText"] = "specialValueText"; + // DPI_StaticImage, having type string + ParameterId["StaticImage"] = "staticImage"; + // DPI_StoryPointBase, having type string + ParameterId["StoryPointBase"] = "storyPointBase"; + // DPI_StoryPointCaption, having type string + ParameterId["StoryPointCaption"] = "storyPointCaption"; + // DPI_Storyboard, having type string + ParameterId["Storyboard"] = "storyboard"; + // DPI_StyledLabel, having type string + ParameterId["StyledLabel"] = "styledLabel"; + // DPI_SummaryCaption, having type string + ParameterId["SummaryCaption"] = "summaryCaption"; + // DPI_SummaryField, having type string + ParameterId["SummaryField"] = "summaryField"; + // DPI_TableauVersion, having type string + ParameterId["TableauVersion"] = "tableauVersion"; + // DPI_TableFilter, having type string + ParameterId["TableFilter"] = "tableFilter"; + // DPI_TableFilterPrompt, having type string + ParameterId["TableFilterPrompt"] = "tableFilterPrompt"; + // DPI_TagsLabel, having type string + ParameterId["TagsLabel"] = "tagsLabel"; + // DPI_Target, having type string + ParameterId["Target"] = "target"; + // DPI_ThumbnailGroup, having type string + ParameterId["ThumbnailGroup"] = "thumbnailGroup"; + // DPI_ThumbnailUser, having type string + ParameterId["ThumbnailUser"] = "thumbnailUser"; + // DPI_TimeFormat, having type string + ParameterId["TimeFormat"] = "timeFormat"; + // DPI_TrendLineErrorString, having type string + ParameterId["TrendLineErrorString"] = "trendLineErrorString"; + // DPI_TrendLineModelFormula, having type string + ParameterId["TrendLineModelFormula"] = "trendLineModelFormula"; + // DPI_URLString, having type string + ParameterId["URLString"] = "urlString"; + // DPI_URLTest, having type string + ParameterId["URLTest"] = "urlTest"; + // DPI_ValidationMessage, having type string + ParameterId["ValidationMessage"] = "validationMessage"; + // DPI_ValueStr, having type string + ParameterId["ValueStr"] = "valueString"; + // DPI_VerifiedNonFormattedValue, having type string + ParameterId["VerifiedNonFormattedValue"] = "verifiedUnformattedValue"; + // DPI_WorkbookFullPath, having type string + ParameterId["WorkbookFullPath"] = "workbookFullPath"; + // DPI_WindowTitle, having type string + ParameterId["WindowTitle"] = "windowTitle"; + // DPI_ZoneName, having type string + ParameterId["ZoneName"] = "zoneName"; + // DPI_ZoneParam, having type string + ParameterId["ZoneParam"] = "zoneParam"; + // DPI_DataAlertErrorText, having type string + ParameterId["DataAlertErrorText"] = "dataAlertErrorText"; + // DPI_ExtractTempDirectory, having type string + ParameterId["ExtractTempDirectory"] = "extractTempDir"; + // DPI_DSSubClass, having type string + ParameterId["DSSubClass"] = "dsSubClass"; + // DPI_DbgCommandLine, having type string + ParameterId["DbgCommandLine"] = "debugCommandLine"; + // DPI_DbgLogPath, having type string + ParameterId["DbgLogPath"] = "debugLogPath"; + // DPI_DbgOSVersion, having type string + ParameterId["DbgOSVersion"] = "debugOsVersion"; + // DPI_DbgUserName, having type string + ParameterId["DbgUserName"] = "debugUsername"; + // DPI_ErrorMsg, having type string + ParameterId["ErrorMsg"] = "errorMessage"; + // DPI_ErrorStackTrace, having type string + ParameterId["ErrorStackTrace"] = "errorStackTrace"; + // DPI_ErrorStr, having type string + ParameterId["ErrorStr"] = "errorString"; + // DPI_EventMessage, having type string + ParameterId["EventMessage"] = "eventMessage"; + // DPI_EventTimestamp, having type string + ParameterId["EventTimestamp"] = "eventTimestamp"; + // DPI_ExtractDeltaPath, having type string + ParameterId["ExtractDeltaPath"] = "extractDeltaPath"; + // DPI_ExtractPath, having type string + ParameterId["ExtractPath"] = "extractPath"; + // DPI_ExtractSuggestedPath, having type string + ParameterId["ExtractSuggestedPath"] = "suggestedExtractPath"; + // DPI_ExtractTaskSummary, having type string + ParameterId["ExtractTaskSummary"] = "extractTaskSummary"; + // DPI_FactorsString, having type string + ParameterId["FactorsString"] = "factorsStr"; + // DPI_FormattedFamilyName, having type string + ParameterId["FormattedFamilyName"] = "formattedFamilyName"; + // DPI_FunctionSignature, having type string + ParameterId["FunctionSignature"] = "funcSig"; + // DPI_FunctionTooltip, having type string + ParameterId["FunctionTooltip"] = "funcTooltip"; + // DPI_HelpContents, having type string + ParameterId["HelpContents"] = "helpContents"; + // DPI_MapAttributionText, having type string + ParameterId["MapAttributionText"] = "mapAttributionText"; + // DPI_MapAttributionTextSize, having type string + ParameterId["MapAttributionTextSize"] = "mapAttributionTextSize"; + // DPI_MapAttributionUrl, having type string + ParameterId["MapAttributionUrl"] = "mapAttributionUrl"; + // DPI_MapBoxErrorMessage, having type string + ParameterId["MapBoxErrorMessage"] = "mapboxErrorMessage"; + // DPI_MapBoxOldStyleName, having type string + ParameterId["MapBoxOldStyleName"] = "mapboxOldStyleName"; + // DPI_MapBoxSelectedStyle, having type string + ParameterId["MapBoxSelectedStyle"] = "mapboxSelectedStyle"; + // DPI_MapBoxStyleName, having type string + ParameterId["MapBoxStyleName"] = "mapboxStyleName"; + // DPI_MapLayerRequest, having type string + ParameterId["MapLayerRequest"] = "mapLayerRequest"; + // DPI_MapServerKey, having type string + ParameterId["MapServerKey"] = "mapServerKey"; + // DPI_MapTileServer, having type string + ParameterId["MapTileServer"] = "mapTileServer"; + // DPI_MapTileUrl, having type string + ParameterId["MapTileUrl"] = "mapTileUrl"; + // DPI_PercentagesString, having type string + ParameterId["PercentagesString"] = "percentagesStr"; + // DPI_PublishErrorMessage, having type string + ParameterId["PublishErrorMessage"] = "publishErrorMessage"; + // DPI_TdePath, having type string + ParameterId["TdePath"] = "tdePath"; + // DPI_UIAutomationComponentName, having type string + ParameterId["UIAutomationComponentName"] = "uiAutomationComponentName"; + // DPI_UIAutomationEndTime, having type string + ParameterId["UIAutomationEndTime"] = "uiAutomationEndTime"; + // DPI_UIAutomationName, having type string + ParameterId["UIAutomationName"] = "uiAutomationName"; + // DPI_UIAutomationStartTime, having type string + ParameterId["UIAutomationStartTime"] = "uiAutomationStartTime"; + // DPI_UIAutomationValue, having type string + ParameterId["UIAutomationValue"] = "uiAutomationValue"; + // DPI_WMSConnectionName, having type string + ParameterId["WMSConnectionName"] = "wmsConnectionName"; + // DPI_WMSOldConnectionName, having type string + ParameterId["WMSOldConnectionName"] = "wmsOldConnectionName"; + // DPI_WMSServerUrl, having type string + ParameterId["WMSServerUrl"] = "wmsServerUrl"; + // DPI_AboutBuildVersion, having type string + ParameterId["AboutBuildVersion"] = "aboutBuildVersion"; + // DPI_ActionFields, having type string + ParameterId["ActionFields"] = "actionFields"; + // DPI_AddVariableLabel, having type string + ParameterId["AddVariableLabel"] = "addVariableLabel"; + // DPI_AddVariableTooltip, having type string + ParameterId["AddVariableTooltip"] = "addVariableTooltip"; + // DPI_AllowedDataSourcesByName, having type string + ParameterId["AllowedDataSourcesByName"] = "allowedDataSourcesByName"; + // DPI_AppAboutVersion, having type string + ParameterId["AppAboutVersion"] = "appAboutVersion"; + // DPI_AppBuildBranchName, having type string + ParameterId["AppBuildBranchName"] = "appBuildBranchName"; + // DPI_AppBuildVersion, having type string + ParameterId["AppBuildVersion"] = "appBuildVersion"; + // DPI_AppExternalVersion, having type string + ParameterId["AppExternalVersion"] = "appExternalVersion"; + // DPI_AppName, having type string + ParameterId["AppName"] = "appName"; + // DPI_AppProductVersion, having type string + ParameterId["AppProductVersion"] = "appProductVersion"; + // DPI_OriginalVersion, having type string + ParameterId["OriginalVersion"] = "originalVersion"; + // DPI_AtTheLevelSpecialCaption, having type string + ParameterId["AtTheLevelSpecialCaption"] = "atTheLevelSpecialCaption"; + // DPI_AutoCompleteCalc, having type string + ParameterId["AutoCompleteCalc"] = "acCalc"; + // DPI_CSVPath, having type string + ParameterId["CSVPath"] = "csvPath"; + // DPI_CommandNamespace, having type string + ParameterId["CommandNamespace"] = "commandNamespace"; + // DPI_Condition, having type string + ParameterId["Condition"] = "condition"; + // DPI_ConditionSummary, having type string + ParameterId["ConditionSummary"] = "conditionSummary"; + // DPI_ConfirmationMsg, having type string + ParameterId["ConfirmationMsg"] = "confirmationMsg"; + // DPI_DashboardTypeText, having type string + ParameterId["DashboardTypeText"] = "dashboardType"; + // DPI_DataserverPublicAddress, having type string + ParameterId["DataserverPublicAddress"] = "dataserverPublicAddress"; + // DPI_DatasourceFileName, having type string + ParameterId["DatasourceFileName"] = "datasourceFileName"; + // DPI_DecimalMark, having type string + ParameterId["DecimalMark"] = "decimalMark"; + // DPI_DeleteVariableTooltip, having type string + ParameterId["DeleteVariableTooltip"] = "deleteVariableTooltip"; + // DPI_DialogTitle, having type string + ParameterId["DialogTitle"] = "dialogTitle"; + // DPI_DisplayValue, having type string + ParameterId["DisplayValue"] = "displayValue"; + // DPI_TooltipValue, having type string + ParameterId["TooltipValue"] = "tooltipValue"; + // DPI_DstPath, having type string + ParameterId["DstPath"] = "dstPath"; + // DPI_EditWidgetHeader, having type string + ParameterId["EditWidgetHeader"] = "editWidgetHeader"; + // DPI_EditWidgetInstruction, having type string + ParameterId["EditWidgetInstruction"] = "editWidgetInstruction"; + // DPI_EndSelectionCaption, having type string + ParameterId["EndSelectionCaption"] = "endSelectionCaption"; + // DPI_ErrorConfirmationQuestion, having type string + ParameterId["ErrorConfirmationQuestion"] = "errorConfirmationQuestion"; + // DPI_ErrorDialogTitle, having type string + ParameterId["ErrorDialogTitle"] = "errorDialogTitle"; + // DPI_ErrorHelpLink, having type string + ParameterId["ErrorHelpLink"] = "errorHelpLink"; + // DPI_ErrorShortMessage, having type string + ParameterId["ErrorShortMessage"] = "errorShortMessage"; + // DPI_FilterSearchQuery, having type string + ParameterId["FilterSearchQuery"] = "filterSearchQuery"; + // DPI_FromLabel, having type string + ParameterId["FromLabel"] = "fromLabel"; + // DPI_FunctionHelp, having type string + ParameterId["FunctionHelp"] = "functionHelp"; + // DPI_Instructions, having type string + ParameterId["Instructions"] = "instructions"; + // DPI_LargeUnitDisplay, having type string + ParameterId["LargeUnitDisplay"] = "largeUnitDisplay"; + // DPI_Limit, having type string + ParameterId["Limit"] = "limit"; + // DPI_ListViewNameLabel, having type string + ParameterId["ListViewNameLabel"] = "listViewNameLabel"; + // DPI_ListViewValueLabel, having type string + ParameterId["ListViewValueLabel"] = "listViewValueLabel"; + // DPI_MapScaleReadoutUnit, having type string + ParameterId["MapScaleReadoutUnit"] = "mapScaleReadoutUnit"; + // DPI_MeasureDimension, having type string + ParameterId["MeasureDimension"] = "measuresDimension"; + // DPI_MimeType, having type string + ParameterId["MimeType"] = "mimeType"; + // DPI_NotificationMsg, having type string + ParameterId["NotificationMsg"] = "notificationMsg"; + // DPI_OperationName, having type string + ParameterId["OperationName"] = "operationName"; + // DPI_PageTitle, having type string + ParameterId["PageTitle"] = "pageTitle"; + // DPI_PatternSummary, having type string + ParameterId["PatternSummary"] = "patternSummary"; + // DPI_ReferenceLineId, having type string + ParameterId["ReferenceLineId"] = "refLineId"; + // DPI_ReferenceLinePairedId, having type string + ParameterId["ReferenceLinePairedId"] = "refLinePairedId"; + // DPI_ReplaceText, having type string + ParameterId["ReplaceText"] = "replaceText"; + // DPI_RequiredVariableMessage, having type string + ParameterId["RequiredVariableMessage"] = "requiredVariableMessage"; + // DPI_RestartEverySpecialCaption, having type string + ParameterId["RestartEverySpecialCaption"] = "restartEverySpecialCaption"; + // DPI_Root, having type string + ParameterId["Root"] = "root"; + // DPI_SelectionSummary, having type string + ParameterId["SelectionSummary"] = "selectionSummary"; + // DPI_SessionAttributeKey, having type string + ParameterId["SessionAttributeKey"] = "sessionAttributeKey"; + // DPI_SessionAttributeValue, having type string + ParameterId["SessionAttributeValue"] = "sessionAttributeValue"; + // DPI_SheetAttributeKey, having type string + ParameterId["SheetAttributeKey"] = "baseSheetAttributeKey"; + // DPI_SheetAttributeValue, having type string + ParameterId["SheetAttributeValue"] = "baseSheetAttributeValue"; + // DPI_SmallUnitDisplay, having type string + ParameterId["SmallUnitDisplay"] = "smallUnitDisplay"; + // DPI_SourceCaption, having type string + ParameterId["SourceCaption"] = "sourceCaption"; + // DPI_SrcPath, having type string + ParameterId["SrcPath"] = "srcPath"; + // DPI_StartSelectionCaption, having type string + ParameterId["StartSelectionCaption"] = "startSelectionCaption"; + // DPI_Subtitle, having type string + ParameterId["Subtitle"] = "subtitle"; + // DPI_TableauServerSiteName, having type string + ParameterId["TableauServerSiteName"] = "tableauServerSiteName"; + // DPI_TargetCaption, having type string + ParameterId["TargetCaption"] = "targetCaption"; + // DPI_ThumbnailPath, having type string + ParameterId["ThumbnailPath"] = "thumbnailPath"; + // DPI_ToLabel, having type string + ParameterId["ToLabel"] = "toLabel"; + // DPI_URLAddress, having type string + ParameterId["URLAddress"] = "urlAddress"; + // DPI_UrlRoot, having type string + ParameterId["UrlRoot"] = "urlRoot"; + // DPI_ValuesTableHeader, having type string + ParameterId["ValuesTableHeader"] = "valuesTableHeader"; + // DPI_ValuesTableHeader2, having type string + ParameterId["ValuesTableHeader2"] = "valuesTableHeader2"; + // DPI_VariableDescription, having type string + ParameterId["VariableDescription"] = "variableDescription"; + // DPI_VariableDisplayName, having type string + ParameterId["VariableDisplayName"] = "variableDisplayName"; + // DPI_VariableGUID, having type string + ParameterId["VariableGUID"] = "variableGuid"; + // DPI_VerboseName, having type string + ParameterId["VerboseName"] = "verboseName"; + // DPI_ViewId, having type string + ParameterId["ViewId"] = "viewId"; + // DPI_Warning1, having type string + ParameterId["Warning1"] = "warning1"; + // DPI_Warning2, having type string + ParameterId["Warning2"] = "warning2"; + // DPI_RefreshToken, having type string + ParameterId["RefreshToken"] = "refresh_token"; + // DPI_TokenType, having type string + ParameterId["TokenType"] = "token_type"; + // DPI_XSRFToken, having type string + ParameterId["XSRFToken"] = "xsrf_token"; + // DPI_AxisSubtitle, having type string + ParameterId["AxisSubtitle"] = "axisSubtitle"; + // DPI_AxisTitle, having type string + ParameterId["AxisTitle"] = "axisTitle"; + // DPI_TickMarkOriginDataValue, having type string + ParameterId["TickMarkOriginDataValue"] = "tickMarkOriginDataValue"; + // DPI_TickMarkOriginDataValueNoTime, having type string + ParameterId["TickMarkOriginDataValueNoTime"] = "tickMarkOriginDataValueNoTime"; + // DPI_TickMarkSpacingDataValue, having type string + ParameterId["TickMarkSpacingDataValue"] = "tickMarkSpacingDataValue"; + // DPI_ExtractActionLocalized, having type string + ParameterId["ExtractActionLocalized"] = "extractActionLocalized"; + // DPI_ExtractSource, having type string + ParameterId["ExtractSource"] = "extractSource"; + // DPI_FileContents, having type string + ParameterId["FileContents"] = "fileContents"; + // DPI_SaveImagePath, having type string + ParameterId["SaveImagePath"] = "saveImagePath"; + // DPI_WidgetUID, having type string + ParameterId["WidgetUID"] = "widgetUniqueId"; + // DPI_DatePropertiesDisplayText, having type string + ParameterId["DatePropertiesDisplayText"] = "datePropertiesDisplayText"; + // DPI_DatePropertiesHelperText, having type string + ParameterId["DatePropertiesHelperText"] = "datePropertiesHelperText"; + // DPI_EventName, having type string + ParameterId["EventName"] = "eventName"; + // DPI_ExceptionType, having type string + ParameterId["ExceptionType"] = "exceptionType"; + // DPI_SearchPlaceholder, having type string + ParameterId["SearchPlaceholder"] = "searchPlaceholder"; + // DPI_TargetVersion, having type string + ParameterId["TargetVersion"] = "targetVersion"; + // DPI_DataValueDisplayString, having type string + ParameterId["DataValueDisplayString"] = "dataValueDisplayString"; + // DPI_DomainString, having type string + ParameterId["DomainString"] = "domainString"; + // DPI_RawDataValueString, having type string + ParameterId["RawDataValueString"] = "rawDataValueString"; + // DPI_RichTextDialogTitle, having type string + ParameterId["RichTextDialogTitle"] = "richTextDialogTitle"; + // DPI_RichTextContent, having type string + ParameterId["RichTextContent"] = "richTextContent"; + // DPI_MarkSizeAsString, having type string + ParameterId["MarkSizeAsString"] = "markSizeAsString"; + // DPI_UnitsLabel, having type string + ParameterId["UnitsLabel"] = "unitsLabel"; + // DPI_EmailAddress, having type string + ParameterId["EmailAddress"] = "emailAddress"; + // DPI_FirstName, having type string + ParameterId["FirstName"] = "firstName"; + // DPI_LastName, having type string + ParameterId["LastName"] = "lastName"; + // DPI_SummaryCardAvg, having type string + ParameterId["SummaryCardAvg"] = "summaryCardAvg"; + // DPI_SummaryCardCaption, having type string + ParameterId["SummaryCardCaption"] = "summaryCardCaption"; + // DPI_SummaryCardCount, having type string + ParameterId["SummaryCardCount"] = "summaryCardCount"; + // DPI_SummaryCardKurtosis, having type string + ParameterId["SummaryCardKurtosis"] = "summaryCardKurtosis"; + // DPI_SummaryCardMax, having type string + ParameterId["SummaryCardMax"] = "summaryCardMax"; + // DPI_SummaryCardMedian, having type string + ParameterId["SummaryCardMedian"] = "summaryCardMedian"; + // DPI_SummaryCardMin, having type string + ParameterId["SummaryCardMin"] = "summaryCardMin"; + // DPI_SummaryCardQuart1, having type string + ParameterId["SummaryCardQuart1"] = "summaryCardQuart1"; + // DPI_SummaryCardQuart3, having type string + ParameterId["SummaryCardQuart3"] = "summaryCardQuart3"; + // DPI_SummaryCardSkewness, having type string + ParameterId["SummaryCardSkewness"] = "summaryCardSkewness"; + // DPI_SummaryCardStdev, having type string + ParameterId["SummaryCardStdev"] = "summaryCardStdev"; + // DPI_SummaryCardSum, having type string + ParameterId["SummaryCardSum"] = "summaryCardSum"; + // DPI_ValueClassAttr, having type string + ParameterId["ValueClassAttr"] = "valueClassAttr"; + // DPI_TrendLineDialogTitle, having type string + ParameterId["TrendLineDialogTitle"] = "trendLineDialogTitle"; + // DPI_LinearFitTypeLabel, having type string + ParameterId["LinearFitTypeLabel"] = "linearFitTypeLabel"; + // DPI_LogFitTypeLabel, having type string + ParameterId["LogFitTypeLabel"] = "logFitTypeLabel"; + // DPI_ExpFitTypeLabel, having type string + ParameterId["ExpFitTypeLabel"] = "expFitTypeLabel"; + // DPI_PowerFitTypeLabel, having type string + ParameterId["PowerFitTypeLabel"] = "powerFitTypeLabel"; + // DPI_PolynomialFitTypeLabel, having type string + ParameterId["PolynomialFitTypeLabel"] = "polynomialFitTypeLabel"; + // DPI_ExcludeColorLabel, having type string + ParameterId["ExcludeColorLabel"] = "excludeColorLabel"; + // DPI_EnableConfidenceBandsLabel, having type string + ParameterId["EnableConfidenceBandsLabel"] = "enableConfidenceBandsLabel"; + // DPI_ForceInterceptZeroLabel, having type string + ParameterId["ForceInterceptZeroLabel"] = "forceInterceptZero label"; + // DPI_EnableInstantAnalyticsLabel, having type string + ParameterId["EnableInstantAnalyticsLabel"] = "enableInstantAnalyticsLabel"; + // DPI_EnableTooltipsLabel, having type string + ParameterId["EnableTooltipsLabel"] = "enableTooltipLabel"; + // DPI_AuthenticationSummary, having type string + ParameterId["AuthenticationSummary"] = "authenticationSummary"; + // DPI_BtnCancelText, having type string + ParameterId["BtnCancelText"] = "btnCancelText"; + // DPI_BtnOkText, having type string + ParameterId["BtnOkText"] = "btnOkText"; + // DPI_ButtonText, having type string + ParameterId["ButtonText"] = "buttonText"; + // DPI_CalculationCaption, having type string + ParameterId["CalculationCaption"] = "calculationCaption"; + // DPI_CalculationDependencies, having type string + ParameterId["CalculationDependencies"] = "calculationDependencies"; + // DPI_CalculationFormula, having type string + ParameterId["CalculationFormula"] = "calculationFormula"; + // DPI_CheckPublishMessage, having type string + ParameterId["CheckPublishMessage"] = "checkPublishSummary"; + // DPI_ClusterModelText, having type string + ParameterId["ClusterModelText"] = "clusterModelText"; + // DPI_ClusterSummaryScaledText, having type string + ParameterId["ClusterSummaryScaledText"] = "clusterSummaryScaledText"; + // DPI_ClusterSummaryText, having type string + ParameterId["ClusterSummaryText"] = "clusterSummaryText"; + // DPI_ColumnCaption, having type string + ParameterId["ColumnCaption"] = "columnCaption"; + // DPI_DatasourceCaption, having type string + ParameterId["DatasourceCaption"] = "datasourceCaption"; + // DPI_DefaultCaption, having type string + ParameterId["DefaultCaption"] = "defaultCaption"; + // DPI_DisplayString, having type string + ParameterId["DisplayString"] = "displayText"; + // DPI_DragDescription, having type string + ParameterId["DragDescription"] = "dragDescription"; + // DPI_ExceptionMessage, having type string + ParameterId["ExceptionMessage"] = "exceptionMessage"; + // DPI_Explanation, having type string + ParameterId["Explanation"] = "explanation"; + // DPI_FieldCaption, having type string + ParameterId["FieldCaption"] = "fieldCaption"; + // DPI_FieldSummary, having type string + ParameterId["FieldSummary"] = "fieldSummary"; + // DPI_FieldSummaryLabel, having type string + ParameterId["FieldSummaryLabel"] = "fieldSummaryLabel"; + // DPI_FilterDescription, having type string + ParameterId["FilterDescription"] = "filterDescription"; + // DPI_FilterName, having type string + ParameterId["FilterName"] = "filterName"; + // DPI_ForecastModelText, having type string + ParameterId["ForecastModelText"] = "forecastModelText"; + // DPI_ForecastSummaryPctText, having type string + ParameterId["ForecastSummaryPctText"] = "forecastSummaryPctText"; + // DPI_ForecastSummaryText, having type string + ParameterId["ForecastSummaryText"] = "forecastSummaryText"; + // DPI_HasActiveExtractText, having type string + ParameterId["HasActiveExtractText"] = "hasActiveExtractText"; + // DPI_HtmlColor, having type string + ParameterId["HtmlColor"] = "htmlColor"; + // DPI_IncludeLocalFilesCheckedWarning, having type string + ParameterId["IncludeLocalFilesCheckedWarning"] = "includeLocalFilesCheckedWarning"; + // DPI_IncludeLocalFilesWarning, having type string + ParameterId["IncludeLocalFilesWarning"] = "includeLocalFilesWarning"; + // DPI_InvalidFieldCaption, having type string + ParameterId["InvalidFieldCaption"] = "invalidFieldCaption"; + // DPI_LimitSummary, having type string + ParameterId["LimitSummary"] = "limitSummary"; + // DPI_LoadedExistingObjectWarning, having type string + ParameterId["LoadedExistingObjectWarning"] = "loadedExistingObjectWarning"; + // DPI_ManageDatasourcesSummary, having type string + ParameterId["ManageDatasourcesSummary"] = "manageDatasourcesSummary"; + // DPI_ModalDialog, having type string + ParameterId["ModalDialog"] = "modalDialog"; + // DPI_NewDatasourceCaption, having type string + ParameterId["NewDatasourceCaption"] = "newDatasourceCaption"; + // DPI_PermissionsButtonLabel, having type string + ParameterId["PermissionsButtonLabel"] = "permissionsButtonLabel"; + // DPI_PermissionsEditorRoleId, having type string + ParameterId["PermissionsEditorRoleId"] = "permissionsEditorRoleId"; + // DPI_PermissionsLabel, having type string + ParameterId["PermissionsLabel"] = "permissionsLabel"; + // DPI_PerspectiveCaption, having type string + ParameterId["PerspectiveCaption"] = "perspectiveCaption"; + // DPI_PublishButtonLabel, having type string + ParameterId["PublishButtonLabel"] = "publishButtonLabel"; + // DPI_PublishChoiceLabel, having type string + ParameterId["PublishChoiceLabel"] = "publishChoiceLabel"; + // DPI_PublishObjectViewsSummary, having type string + ParameterId["PublishObjectViewsSummary"] = "publishObjectViewsSummary"; + // DPI_QualifiedFieldCaption, having type string + ParameterId["QualifiedFieldCaption"] = "qualifiedFieldCaption"; + // DPI_RelationshipTooltipText, having type string + ParameterId["RelationshipTooltipText"] = "relationshipTooltipText"; + // DPI_ResetObjectAttributesWarning, having type string + ParameterId["ResetObjectAttributesWarning"] = "resetObjectAttributesWarning"; + // DPI_RowCountCaption, having type string + ParameterId["RowCountCaption"] = "rowCountCaption"; + // DPI_ServerCaption, having type string + ParameterId["ServerCaption"] = "serverCaption"; + // DPI_SizeModeName, having type string + ParameterId["SizeModeName"] = "sizeModeName"; + // DPI_SummaryText, having type string + ParameterId["SummaryText"] = "summaryText"; + // DPI_SyncClientUseExtractLabel, having type string + ParameterId["SyncClientUseExtractLabel"] = "syncClientUseExtractLabel"; + // DPI_Text, having type string + ParameterId["Text"] = "text"; + // DPI_TextDropdownControlLabel, having type string + ParameterId["TextDropdownControlLabel"] = "controlLabel"; + // DPI_ThumbnailUserName, having type string + ParameterId["ThumbnailUserName"] = "thumbnailUserName"; + // DPI_TitleString, having type string + ParameterId["TitleString"] = "titleString"; + // DPI_TooltipText, having type string + ParameterId["TooltipText"] = "tooltipText"; + // DPI_UpdatedCalcCaption, having type string + ParameterId["UpdatedCalcCaption"] = "updatedCalculationCaption"; + // DPI_UpdatedCalcFormula, having type string + ParameterId["UpdatedCalcFormula"] = "updatedCalculationFormula"; + // DPI_UserCaption, having type string + ParameterId["UserCaption"] = "userCaption"; + // DPI_WarningTooltipText, having type string + ParameterId["WarningTooltipText"] = "warningTooltipText"; + // DPI_DatasourceFile, having type string + ParameterId["DatasourceFile"] = "datasourceFile"; + // DPI_File, having type string + ParameterId["File"] = "file"; + // DPI_FileNameBase, having type string + ParameterId["FileNameBase"] = "filenameBase"; + // DPI_NewFile, having type string + ParameterId["NewFile"] = "newFile"; + // DPI_OriginalFile, having type string + ParameterId["OriginalFile"] = "originalFile"; + // DPI_OutputFile, having type string + ParameterId["OutputFile"] = "outputFile"; + // DPI_SampleFileName, having type string + ParameterId["SampleFileName"] = "sampleFilename"; + // DPI_WorkbookFile, having type string + ParameterId["WorkbookFile"] = "workbookFile"; + // DPI_ImageKey, having type string + ParameterId["ImageKey"] = "imageKey"; + // DPI_OverlayImageKey, having type string + ParameterId["OverlayImageKey"] = "overlayImageKey"; + // DPI_TempFileKey, having type string + ParameterId["TempFileKey"] = "tempfileKey"; + // DPI_CapturedSheet, having type string + ParameterId["CapturedSheet"] = "capturedSheet"; + // DPI_CurrentSheet, having type string + ParameterId["CurrentSheet"] = "currentSheet"; + // DPI_Dashboard, having type string + ParameterId["Dashboard"] = "dashboard"; + // DPI_EnsureSheet, having type string + ParameterId["EnsureSheet"] = "ensureSheetName"; + // DPI_NewSheet, having type string + ParameterId["NewSheet"] = "newSheet"; + // DPI_Sheet, having type string + ParameterId["Sheet"] = "sheet"; + // DPI_SheetName, having type string + ParameterId["SheetName"] = "sheetName"; + // DPI_SourceDashboard, having type string + ParameterId["SourceDashboard"] = "sourceDashboard"; + // DPI_SourceSheet, having type string + ParameterId["SourceSheet"] = "sourceSheet"; + // DPI_TargetSheet, having type string + ParameterId["TargetSheet"] = "targetSheet"; + // DPI_WorkbookName, having type string + ParameterId["WorkbookName"] = "workbookName"; + // DPI_Worksheet, having type string + ParameterId["Worksheet"] = "worksheet"; + // DPI_BaseViewThumbLink, having type string + ParameterId["BaseViewThumbLink"] = "baseViewThumbLink"; + // DPI_BlogLink, having type string + ParameterId["BlogLink"] = "blogLink"; + // DPI_CacheUrl, having type string + ParameterId["CacheUrl"] = "cacheUrl"; + // DPI_DownloadLink, having type string + ParameterId["DownloadLink"] = "downloadLink"; + // DPI_RepositoryUrl, having type string + ParameterId["RepositoryUrl"] = "repositoryUrl"; + // DPI_ShareLink, having type string + ParameterId["ShareLink"] = "shareLink"; + // DPI_URL, having type string + ParameterId["URL"] = "url"; + // DPI_ClusterModelHtml, having type string + ParameterId["ClusterModelHtml"] = "clusterModelHtml"; + // DPI_ClusterSummaryHtml, having type string + ParameterId["ClusterSummaryHtml"] = "clusterSummaryHtml"; + // DPI_ClusterSummaryScaledHtml, having type string + ParameterId["ClusterSummaryScaledHtml"] = "clusterSummaryScaledHtml"; + // DPI_FieldDescription, having type string + ParameterId["FieldDescription"] = "fieldDescription"; + // DPI_ForecastModelHtml, having type string + ParameterId["ForecastModelHtml"] = "forecastModelHtml"; + // DPI_ForecastSummaryHtml, having type string + ParameterId["ForecastSummaryHtml"] = "forecastSummaryHtml"; + // DPI_ForecastSummaryPctHtml, having type string + ParameterId["ForecastSummaryPctHtml"] = "forecastSummaryPctHtml"; + // DPI_Html, having type string + ParameterId["Html"] = "html"; + // DPI_HtmlSelection, having type string + ParameterId["HtmlSelection"] = "htmlSelection"; + // DPI_HtmlTooltip, having type string + ParameterId["HtmlTooltip"] = "htmlTooltip"; + // DPI_HtmlTooltipModified, having type string + ParameterId["HtmlTooltipModified"] = "htmlTooltipModified"; + // DPI_TitleHtml, having type string + ParameterId["TitleHtml"] = "titleHtml"; + // DPI_CacheUrlInfoJson, having type string + ParameterId["CacheUrlInfoJson"] = "cacheUrlInfoJson"; + // DPI_FilterSearchJson, having type string + ParameterId["FilterSearchJson"] = "filterSearchJson"; + // DPI_FilterSearchWithIndexJson, having type string + ParameterId["FilterSearchWithIndexJson"] = "filterSearchWithIndexJson"; + // DPI_FilterShowChildrenJson, having type string + ParameterId["FilterShowChildrenJson"] = "filterShowChildrenJson"; + // DPI_FiltersJson, having type string + ParameterId["FiltersJson"] = "filtersJson"; + // DPI_FrameJson, having type string + ParameterId["FrameJson"] = "frameJson"; + // DPI_GeometryJson, having type string + ParameterId["GeometryJson"] = "geometryJson"; + // DPI_GetFilterItemsJson, having type string + ParameterId["GetFilterItemsJson"] = "getFilterItemsJson"; + // DPI_KeepOnlyResponseJson, having type string + ParameterId["KeepOnlyResponseJson"] = "keepOnlyResponseJson"; + // DPI_MenuCommandsJson, having type string + ParameterId["MenuCommandsJson"] = "menuCommandsJson"; + // DPI_ModifiedSheetsJson, having type string + ParameterId["ModifiedSheetsJson"] = "modifiedSheetsJson"; + // DPI_ParameterCtrlJson, having type string + ParameterId["ParameterCtrlJson"] = "parameterCtrlJson"; + // DPI_ViewJson, having type string + ParameterId["ViewJson"] = "viewJson"; + // DPI_CustomizedViewXML, having type string + ParameterId["CustomizedViewXML"] = "customizedViewXml"; + // DPI_DatasourceDeltaXML, having type string + ParameterId["DatasourceDeltaXML"] = "datasourceDeltaXml"; + // DPI_DatasourceXML, having type string + ParameterId["DatasourceXML"] = "datasourceXml"; + // DPI_KeychainXML, having type string + ParameterId["KeychainXML"] = "keychainXml"; + // DPI_PermissionsModelXML, having type string + ParameterId["PermissionsModelXML"] = "permissionsModelXml"; + // DPI_SharedViewsXML, having type string + ParameterId["SharedViewsXML"] = "sharedViewsXml"; + // DPI_TargetURL, having type string + ParameterId["TargetURL"] = "targetUrl"; + // DPI_Anchor, having type string + ParameterId["Anchor"] = "anchor"; + // DPI_CenterValue, having type string + ParameterId["CenterValue"] = "centerValue"; + // DPI_ComputedBinSize, having type string + ParameterId["ComputedBinSize"] = "computedBinSize"; + // DPI_ConstantValue, having type string + ParameterId["ConstantValue"] = "constantValue"; + // DPI_PairedConstantValue, having type string + ParameterId["PairedConstantValue"] = "pairedConstantValue"; + // DPI_CountDistinct, having type string + ParameterId["CountDistinct"] = "countDistinct"; + // DPI_DataMax, having type string + ParameterId["DataMax"] = "dataMax"; + // DPI_DataMin, having type string + ParameterId["DataMin"] = "dataMin"; + // DPI_DataValueString, having type string + ParameterId["DataValueString"] = "dataValueStr"; + // DPI_EndValue, having type string + ParameterId["EndValue"] = "endValue"; + // DPI_RangeMax, having type string + ParameterId["RangeMax"] = "rangeMax"; + // DPI_RangeMin, having type string + ParameterId["RangeMin"] = "rangeMin"; + // DPI_RangeStepSize, having type string + ParameterId["RangeStepSize"] = "rangeStepSize"; + // DPI_StartValue, having type string + ParameterId["StartValue"] = "startValue"; + // DPI_TargetValue, having type string + ParameterId["TargetValue"] = "targetValue"; + // DPI_ValueInc, having type string + ParameterId["ValueInc"] = "valueInc"; + // DPI_ValueMax, having type string + ParameterId["ValueMax"] = "valueMax"; + // DPI_ValueMin, having type string + ParameterId["ValueMin"] = "valueMin"; + // DPI_QuantilesValue, having type string + ParameterId["QuantilesValue"] = "quantilesValue"; + // DPI_UserInputBinSize, having type string + ParameterId["UserInputBinSize"] = "userBinSize"; + // DPI_AddedDataSources, having type string[] + ParameterId["AddedDataSources"] = "addedDataSourceNames"; + // DPI_AddressingCaptions, having type string[] + ParameterId["AddressingCaptions"] = "addressingCaptions"; + // DPI_AggregationCaptions, having type string[] + ParameterId["AggregationCaptions"] = "aggregationCaptions"; + // DPI_AtTheLevelCaptions, having type string[] + ParameterId["AtTheLevelCaptions"] = "atTheLevelCaptions"; + // DPI_AuthenticationSettingLabels, having type string[] + ParameterId["AuthenticationSettingLabels"] = "authenticationSettingLabels"; + // DPI_AutosaveFileIdsVector, having type string[] + ParameterId["AutosaveFileIdsVector"] = "autosaveFileIdsVector"; + // DPI_ChangedTuples, having type string[] + ParameterId["ChangedTuples"] = "changedTuples"; + // DPI_CharsetsAvailable, having type string[] + ParameterId["CharsetsAvailable"] = "charsetsAvailable"; + // DPI_CharsetDisplayNames, having type string[] + ParameterId["CharsetDisplayNames"] = "charsetDisplayNames"; + // DPI_ColorFactors, having type string[] + ParameterId["ColorFactors"] = "colorFactors"; + // DPI_ColumnFullNames, having type string[] + ParameterId["ColumnFullNames"] = "columnFullNames"; + // DPI_ConnectionNames, having type string[] + ParameterId["ConnectionNames"] = "connectionNames"; + // DPI_ConnectionCaptions, having type string[] + ParameterId["ConnectionCaptions"] = "connectionCaptions"; + // DPI_ConnectionBigQueryLegacySQLCheckBox, having type string[] + ParameterId["ConnectionBigQueryLegacySQLCheckBox"] = "connectionBigqueryLegacySqlCheckbox"; + // DPI_CustomFieldOrder, having type string[] + ParameterId["CustomFieldOrder"] = "customFieldOrder"; + // DPI_DataSourceClasses, having type string[] + ParameterId["DataSourceClasses"] = "dataSourceClasses"; + // DPI_DataSourceNames, having type string[] + ParameterId["DataSourceNames"] = "dataSourceNames"; + // DPI_DataSourceNames2, having type string[] + ParameterId["DataSourceNames2"] = "dataSourceNames2"; + // DPI_DataSourcesWithEmptyRelation, having type string[] + ParameterId["DataSourcesWithEmptyRelation"] = "dataSourcesWithEmptyRelation"; + // DPI_DataSourceCreationErrors, having type string[] + ParameterId["DataSourceCreationErrors"] = "dataSourceCreationErrors"; + // DPI_DateFormats, having type string[] + ParameterId["DateFormats"] = "dateFormats"; + // DPI_DayNames, having type string[] + ParameterId["DayNames"] = "dayNames"; + // DPI_DrillPathVector, having type string[] + ParameterId["DrillPathVector"] = "drillpathVector"; + // DPI_ErrorDetails, having type string[] + ParameterId["ErrorDetails"] = "errorDetails"; + // DPI_ExceptionMessageParams, having type string[] + ParameterId["ExceptionMessageParams"] = "exceptionMessageParams"; + // DPI_ExcludedSheets, having type string[] + ParameterId["ExcludedSheets"] = "excludeSheets"; + // DPI_FieldDisplayNames, having type string[] + ParameterId["FieldDisplayNames"] = "fieldDisplayNames"; + // DPI_FieldFolderVector, having type string[] + ParameterId["FieldFolderVector"] = "fieldFolderVector"; + // DPI_FileIds, having type string[] + ParameterId["FileIds"] = "fileIds"; + // DPI_FilePaths, having type string[] + ParameterId["FilePaths"] = "filePaths"; + // DPI_FileNames, having type string[] + ParameterId["FileNames"] = "fileNames"; + // DPI_FilterAdd, having type string[] + ParameterId["FilterAdd"] = "filterAdd"; + // DPI_FilterAliases, having type string[] + ParameterId["FilterAliases"] = "filterValues"; + // DPI_FilterRemove, having type string[] + ParameterId["FilterRemove"] = "filterRemove"; + // DPI_FixedCaptions, having type string[] + ParameterId["FixedCaptions"] = "fixedCaptions"; + // DPI_FontFamilies, having type string[] + ParameterId["FontFamilies"] = "fontFamilies"; + // DPI_FormatStrings, having type string[] + ParameterId["FormatStrings"] = "formatStrings"; + // DPI_FormattedValues, having type string[] + ParameterId["FormattedValues"] = "formattedValues"; + // DPI_FoundTuples, having type string[] + ParameterId["FoundTuples"] = "foundTuples"; + // DPI_FullSchedulesLabels, having type string[] + ParameterId["FullSchedulesLabels"] = "fullSchedulesLabels"; + // DPI_ImageResourceList, having type string[] + ParameterId["ImageResourceList"] = "imageResources"; + // DPI_IncludeList, having type string[] + ParameterId["IncludeList"] = "includeList"; + // DPI_IncrSchedulesLabels, having type string[] + ParameterId["IncrSchedulesLabels"] = "incrSchedulesLabels"; + // DPI_InvalidDates, having type string[] + ParameterId["InvalidDates"] = "invalidDates"; + // DPI_InvalidValues, having type string[] + ParameterId["InvalidValues"] = "invalidValues"; + // DPI_ItemValues, having type string[] + ParameterId["ItemValues"] = "itemValues"; + // DPI_JoinEditableProps, having type string[] + ParameterId["JoinEditableProps"] = "joinEditableProps"; + // DPI_JoinFieldCaptions, having type string[] + ParameterId["JoinFieldCaptions"] = "joinFieldCaptions"; + // DPI_LocaleOptions, having type string[] + ParameterId["LocaleOptions"] = "localeOptions"; + // DPI_LocaleDisplayNames, having type string[] + ParameterId["LocaleDisplayNames"] = "localeDisplayNames"; + // DPI_MapBoxStyleMaps, having type string[] + ParameterId["MapBoxStyleMaps"] = "mapboxStyleMaps"; + // DPI_MapConnectionErrorDetails, having type string[] + ParameterId["MapConnectionErrorDetails"] = "mapConnectionErrorDetails"; + // DPI_SheetNames, having type string[] + ParameterId["SheetNames"] = "sheetNames"; + // DPI_MapSourceNames, having type string[] + ParameterId["MapSourceNames"] = "mapSourceNames"; + // DPI_MarkGeometries, having type string[] + ParameterId["MarkGeometries"] = "markGeometries"; + // DPI_MenuItems, having type string[] + ParameterId["MenuItems"] = "menuItems"; + // DPI_Modes, having type string[] + ParameterId["Modes"] = "modes"; + // DPI_MonthNames, having type string[] + ParameterId["MonthNames"] = "monthNames"; + // DPI_NumberFormats, having type string[] + ParameterId["NumberFormats"] = "numberFormats"; + // DPI_ObjectTextIDs, having type string[] + ParameterId["ObjectTextIDs"] = "objectTextIds"; + // DPI_OldExtracts, having type string[] + ParameterId["OldExtracts"] = "oldExtracts"; + // DPI_OrderingTypeCaptions, having type string[] + ParameterId["OrderingTypeCaptions"] = "orderingTypeCaptions"; + // DPI_PageNames, having type string[] + ParameterId["PageNames"] = "pageNames"; + // DPI_PaneDescriptorKeys, having type string[] + ParameterId["PaneDescriptorKeys"] = "paneDescriptorKeys"; + // DPI_ParamCaptions, having type string[] + ParameterId["ParamCaptions"] = "paramCaptions"; + // DPI_PrecannedDataValues, having type string[] + ParameterId["PrecannedDataValues"] = "precannedDataValues"; + // DPI_PublishChoiceLabels, having type string[] + ParameterId["PublishChoiceLabels"] = "publishChoiceLabels"; + // DPI_RankTypeCaptions, having type string[] + ParameterId["RankTypeCaptions"] = "rankTypeCaptions"; + // DPI_RecentTags, having type string[] + ParameterId["RecentTags"] = "recentTags"; + // DPI_RelativeCaptions, having type string[] + ParameterId["RelativeCaptions"] = "relativeCaptions"; + // DPI_RemovedDataSources, having type string[] + ParameterId["RemovedDataSources"] = "removedDataSourceNames"; + // DPI_RepresentativeTuple, having type string[] + ParameterId["RepresentativeTuple"] = "representativeTuple"; + // DPI_RestartEveryCaptions, having type string[] + ParameterId["RestartEveryCaptions"] = "restartEveryCaptions"; + // DPI_SchemaMemberGlobalNames, having type string[] + ParameterId["SchemaMemberGlobalNames"] = "schemaMemberGlobalNames"; + // DPI_SelectValuesList, having type string[] + ParameterId["SelectValuesList"] = "selectValues"; + // DPI_SelectionValueList, having type string[] + ParameterId["SelectionValueList"] = "selectionValueList"; + // DPI_SortAggCaptions, having type string[] + ParameterId["SortAggCaptions"] = "sortAggCaptions"; + // DPI_SortDirectionCaptions, having type string[] + ParameterId["SortDirectionCaptions"] = "sortDirectionCaptions"; + // DPI_SortFieldCaptions, having type string[] + ParameterId["SortFieldCaptions"] = "sortFieldCaptions"; + // DPI_SortFieldNameVector, having type string[] + ParameterId["SortFieldNameVector"] = "sortFieldnameVector"; + // DPI_SupportedJoinOperators, having type string[] + ParameterId["SupportedJoinOperators"] = "supportedJoinOperators"; + // DPI_TableCalcTypeCaptions, having type string[] + ParameterId["TableCalcTypeCaptions"] = "tableCalcTypeCaptions"; + // DPI_Tags, having type string[] + ParameterId["Tags"] = "tags"; + // DPI_TermVec, having type string[] + ParameterId["TermVec"] = "termVector"; + // DPI_UIAutomationList, having type string[] + ParameterId["UIAutomationList"] = "uiAutomationList"; + // DPI_ReferenceLineValidCustomLabelTags, having type string[] + ParameterId["ReferenceLineValidCustomLabelTags"] = "validReferenceLineCustomLabelTags"; + // DPI_LocalizedKeywords, having type string[] + ParameterId["LocalizedKeywords"] = "localizedKeywords"; + // DPI_AvailableCalendars, having type string[] + ParameterId["AvailableCalendars"] = "availableCalendars"; + // DPI_SheetsToBeDeletedOrHidden, having type string[] + ParameterId["SheetsToBeDeletedOrHidden"] = "sheetsToBeDeletedOrHidden"; + // DPI_AddSheets, having type string[] + ParameterId["AddSheets"] = "addSheets"; + // DPI_NamesOfSubsheets, having type string[] + ParameterId["NamesOfSubsheets"] = "namesOfSubsheets"; + // DPI_RemoveSheets, having type string[] + ParameterId["RemoveSheets"] = "removeSheets"; + // DPI_ScrollOffsetSheets, having type string[] + ParameterId["ScrollOffsetSheets"] = "scrollOffsetSheets"; + // DPI_Sheets, having type string[] + ParameterId["Sheets"] = "sheets"; + // DPI_SourceWorksheets, having type string[] + ParameterId["SourceWorksheets"] = "sourceWorksheets"; + // DPI_TargetExcludes, having type string[] + ParameterId["TargetExcludes"] = "targetExclude"; + // DPI_TargetWorksheets, having type string[] + ParameterId["TargetWorksheets"] = "targetWorksheets"; + // DPI_TileURLs, having type string[] + ParameterId["TileURLs"] = "tileUrls"; + // DPI_Details, having type string[] + ParameterId["Details"] = "details"; + // DPI_FieldCaptions, having type string[] + ParameterId["FieldCaptions"] = "fieldCaptions"; + // DPI_HighlightCaptions, having type string[] + ParameterId["HighlightCaptions"] = "highlightCaptions"; + // DPI_LevelCaptions, having type string[] + ParameterId["LevelCaptions"] = "levelCaptions"; + // DPI_LevelLeafValues, having type string[] + ParameterId["LevelLeafValues"] = "levelLeafValues"; + // DPI_SubstitutionVariables, having type string[] + ParameterId["SubstitutionVariables"] = "substitutionVariables"; + // DPI_SubstitutionVariableValues, having type string[] + ParameterId["SubstitutionVariableValues"] = "substitutionVariableValues"; + // DPI_HtmlTooltips, having type string[] + ParameterId["HtmlTooltips"] = "htmlTooltips"; + // DPI_InvalidFields, having type string[] + ParameterId["InvalidFields"] = "invalidFields"; + // DPI_NamesOfColumns, having type string[] + ParameterId["NamesOfColumns"] = "namesOfColumns"; + // DPI_NamesOfFields, having type string[] + ParameterId["NamesOfFields"] = "namesOfFields"; + // DPI_ReferencedDatasources, having type string[] + ParameterId["ReferencedDatasources"] = "referencedDataSourceList"; + // DPI_CSSAttrs, having type Dictionary(of string) + ParameterId["CSSAttrs"] = "cssAttrs"; + // DPI_DataSourceMap, having type Dictionary(of string) + ParameterId["DataSourceMap"] = "dataSourceMap"; + // DPI_EventParameters, having type Dictionary(of string) + ParameterId["EventParameters"] = "eventParameters"; + // DPI_ExceptionAttrs, having type Dictionary(of string) + ParameterId["ExceptionAttrs"] = "exceptionAttrs"; + // DPI_InvalidSheetMessage, having type Dictionary(of string) + ParameterId["InvalidSheetMessage"] = "invalidSheetMessages"; + // DPI_MapBoxDefaultStyle, having type Dictionary(of string) + ParameterId["MapBoxDefaultStyle"] = "mapboxDefaultStyles"; + // DPI_PaneFormattings, having type Dictionary(of string) + ParameterId["PaneFormattings"] = "paneFormattings"; + // DPI_SourceNameWithCaption, having type Dictionary(of string) + ParameterId["SourceNameWithCaption"] = "sourceNameWithCaption"; + // DPI_ConnectionColorMap, having type Dictionary(of string) + ParameterId["ConnectionColorMap"] = "connectionColorMap"; + // DPI_TargetNameWithCaption, having type Dictionary(of string) + ParameterId["TargetNameWithCaption"] = "targetNameWithCaption"; + // DPI_ViewIds, having type Dictionary(of string) + ParameterId["ViewIds"] = "viewIds"; + // DPI_AddInSettings, having type Dictionary(of string) + ParameterId["AddInSettings"] = "addInSettings"; + // DPI_DatasourceIcons, having type Dictionary(of string) + ParameterId["DatasourceIcons"] = "datasourceIcons"; + // DPI_FormattedText, having type string + ParameterId["FormattedText"] = "formattedText"; + // DPI_IconTooltip, having type string + ParameterId["IconTooltip"] = "iconTooltip"; + // DPI_Title, having type string + ParameterId["Title"] = "title"; + // DPI_Tooltip, having type string + ParameterId["Tooltip"] = "tooltip"; + // DPI_ZoneText, having type string + ParameterId["ZoneText"] = "zoneText"; + // DPI_AlignmentFlags, having type int + ParameterId["AlignmentFlags"] = "alignmentFlags"; + // DPI_AlphaLevel, having type int + ParameterId["AlphaLevel"] = "alphaLevel"; + // DPI_AnovaDF, having type int + ParameterId["AnovaDF"] = "anovaDf"; + // DPI_AtTheLevelIndex, having type int + ParameterId["AtTheLevelIndex"] = "atTheLevelIndex"; + // DPI_AutomaticDrillIdxInVector, having type int + ParameterId["AutomaticDrillIdxInVector"] = "automaticDrillIdxVector"; + // DPI_AutoSize, having type int + ParameterId["AutoSize"] = "automaticSize"; + // DPI_BaseCoord, having type int + ParameterId["BaseCoord"] = "baseCoord"; + // DPI_CalcEditorCursorPosPostDrop, having type int + ParameterId["CalcEditorCursorPosPostDrop"] = "calcEditorCursorPosPostDrop"; + // DPI_CalcEditorDropPos, having type int + ParameterId["CalcEditorDropPos"] = "calcEditorDropPos"; + // DPI_CalcEditorTextSelectionEndPos, having type int + ParameterId["CalcEditorTextSelectionEndPos"] = "calcEditorTextSelectionEndPos"; + // DPI_CalcEditorTextSelectionStartPos, having type int + ParameterId["CalcEditorTextSelectionStartPos"] = "calcEditorTextSelectionStartPos"; + // DPI_CategoricalBinId, having type int + ParameterId["CategoricalBinId"] = "categoricalBinId"; + // DPI_CategoricalFindControllerId, having type int + ParameterId["CategoricalFindControllerId"] = "categoricalFindControllerId"; + // DPI_ClauseToModifyIndex, having type int + ParameterId["ClauseToModifyIndex"] = "clauseToModifyIndex"; + // DPI_ClientRenderPixelLimit, having type int + ParameterId["ClientRenderPixelLimit"] = "clientRenderPixelLimit"; + // DPI_ColCount, having type int + ParameterId["ColCount"] = "colCount"; + // DPI_ColWidth, having type int + ParameterId["ColWidth"] = "colWidth"; + // DPI_ColumnLevels, having type int + ParameterId["ColumnLevels"] = "columnLevels"; + // DPI_ColumnNumber, having type int + ParameterId["ColumnNumber"] = "columnNumber"; + // DPI_ColumnWidth, having type int + ParameterId["ColumnWidth"] = "columnWidth"; + // DPI_ContentHeight, having type int + ParameterId["ContentHeight"] = "contentH"; + // DPI_ContentWidth, having type int + ParameterId["ContentWidth"] = "contentW"; + // DPI_ContentX, having type int + ParameterId["ContentX"] = "contentX"; + // DPI_ContentY, having type int + ParameterId["ContentY"] = "contentY"; + // DPI_Coordinate, having type int + ParameterId["Coordinate"] = "coord"; + // DPI_CurDateAgg, having type int + ParameterId["CurDateAgg"] = "curDateAgg"; + // DPI_CurrentCustViewId, having type int + ParameterId["CurrentCustViewId"] = "currentCustomViewId"; + // DPI_CustomSplitCharacterCountSeparator, having type int + ParameterId["CustomSplitCharacterCountSeparator"] = "customSplitCharacterCountSeparator"; + // DPI_CustomSplitDesiredSplitCount, having type int + ParameterId["CustomSplitDesiredSplitCount"] = "customSplitDesiredSplitCount"; + // DPI_DashboardGridSize, having type int + ParameterId["DashboardGridSize"] = "dashboardGridSize"; + // DPI_DataIndex, having type int + ParameterId["DataIndex"] = "dataIndex"; + // DPI_DecimalPlaces, having type int + ParameterId["DecimalPlaces"] = "decimalPlaces"; + // DPI_DeltaTime, having type int + ParameterId["DeltaTime"] = "deltaTime"; + // DPI_DestPix, having type int + ParameterId["DestPix"] = "destPix"; + // DPI_DeviceIndex, having type int + ParameterId["DeviceIndex"] = "deviceIndex"; + // DPI_Duration, having type int + ParameterId["Duration"] = "duration"; + // DPI_EndPtX, having type int + ParameterId["EndPtX"] = "endX"; + // DPI_EndPtY, having type int + ParameterId["EndPtY"] = "endY"; + // DPI_ErrorLen, having type int + ParameterId["ErrorLen"] = "lengthOfCalcOfError"; + // DPI_ErrorPos, having type int + ParameterId["ErrorPos"] = "startPositionForError"; + // DPI_ExceptionErrorMessageId, having type int + ParameterId["ExceptionErrorMessageId"] = "exceptionErrorMessageId"; + // DPI_ExtentsH, having type int + ParameterId["ExtentsH"] = "extentsHeight"; + // DPI_ExtentsW, having type int + ParameterId["ExtentsW"] = "extentsWidth"; + // DPI_ExtentsX, having type int + ParameterId["ExtentsX"] = "extentsX"; + // DPI_ExtentsY, having type int + ParameterId["ExtentsY"] = "extentsY"; + // DPI_FieldIndex, having type int + ParameterId["FieldIndex"] = "fieldIndex"; + // DPI_FieldNameId, having type int + ParameterId["FieldNameId"] = "fieldNameId"; + // DPI_FirstDayOfWeek, having type int + ParameterId["FirstDayOfWeek"] = "firstDayOfWeek"; + // DPI_FirstLinkedLevel, having type int + ParameterId["FirstLinkedLevel"] = "firstLinkedLevel"; + // DPI_FirstValueIndex, having type int + ParameterId["FirstValueIndex"] = "firstValueIndex"; + // DPI_FixedSizePresetIndex, having type int + ParameterId["FixedSizePresetIndex"] = "fixedSizePresetIndex"; + // DPI_FocusItemIndex, having type int + ParameterId["FocusItemIndex"] = "focusItemIndex"; + // DPI_FontSize, having type int + ParameterId["FontSize"] = "fontSize"; + // DPI_ForecastIntRangeEnd, having type int + ParameterId["ForecastIntRangeEnd"] = "forecastIntRangeEnd"; + // DPI_ForecastIntRangeStart, having type int + ParameterId["ForecastIntRangeStart"] = "forecastIntRangeStart"; + // DPI_FunctionHelpIndex, having type int + ParameterId["FunctionHelpIndex"] = "functionHelpIndex"; + // DPI_GeographicSearchMaxResults, having type int + ParameterId["GeographicSearchMaxResults"] = "geographicSearchMaxResults"; + // DPI_Height, having type int + ParameterId["Height"] = "h"; + // DPI_HierarchyLevel, having type int + ParameterId["HierarchyLevel"] = "hierarchyLevel"; + // DPI_HierarchyLevelLoaded, having type int + ParameterId["HierarchyLevelLoaded"] = "hierarchyLevelLoaded"; + // DPI_HierarchyLevelMinimum, having type int + ParameterId["HierarchyLevelMinimum"] = "hierarchyLevelMinimum"; + // DPI_HierarchyLoadLimit, having type int + ParameterId["HierarchyLoadLimit"] = "hierarchyLoadLimit"; + // DPI_HierarchySelectControllerId, having type int + ParameterId["HierarchySelectControllerId"] = "hierarchySelectControllerId"; + // DPI_HorzTextCell, having type int + ParameterId["HorzTextCell"] = "horzTextCell"; + // DPI_ImageIndex, having type int + ParameterId["ImageIndex"] = "imageIndex"; + // DPI_ImageSizeLimit, having type int + ParameterId["ImageSizeLimit"] = "imageSizeLimit"; + // DPI_TransparentLineMarksLimit, having type int + ParameterId["TransparentLineMarksLimit"] = "transparentLineMarksLimit"; + // DPI_Indent, having type int + ParameterId["Indent"] = "indent"; + // DPI_Index, having type int + ParameterId["Index"] = "idx"; + // DPI_IndexFrom, having type int + ParameterId["IndexFrom"] = "indexFrom"; + // DPI_IndexOffset, having type int + ParameterId["IndexOffset"] = "indexOffset"; + // DPI_IndexRelativeDateField, having type int + ParameterId["IndexRelativeDateField"] = "indiexRelativeDateField"; + // DPI_IndexSelectedItem, having type int + ParameterId["IndexSelectedItem"] = "indexSelectedItem"; + // DPI_IndexTo, having type int + ParameterId["IndexTo"] = "indexTo"; + // DPI_InlineConnectionRenameRow, having type int + ParameterId["InlineConnectionRenameRow"] = "inlineConnectionRenameRow"; + // DPI_InsertPos, having type int + ParameterId["InsertPos"] = "insertPos"; + // DPI_IsHasDataSupported, having type int + ParameterId["IsHasDataSupported"] = "isHasDataSupported"; + // DPI_LeftMargin, having type int + ParameterId["LeftMargin"] = "leftMargin"; + // DPI_LeftRightBorderWidth, having type int + ParameterId["LeftRightBorderWidth"] = "leftRightBorderWidth"; + // DPI_LevelNumber, having type int + ParameterId["LevelNumber"] = "levelNumber"; + // DPI_LowerBound, having type int + ParameterId["LowerBound"] = "lowerBound"; + // DPI_MapRequestPixels, having type int + ParameterId["MapRequestPixels"] = "mapRequestPixels"; + // DPI_MapScaleFontSizePixels, having type int + ParameterId["MapScaleFontSizePixels"] = "mapScaleFontSizePixels"; + // DPI_MapScaleReadoutNumber, having type int + ParameterId["MapScaleReadoutNumber"] = "mapScaleReadoutNumber"; + // DPI_MapScaleWidth, having type int + ParameterId["MapScaleWidth"] = "mapScaleWidth"; + // DPI_MapTileSize, having type int + ParameterId["MapTileSize"] = "mapTileSize"; + // DPI_Margin, having type int + ParameterId["Margin"] = "margin"; + // DPI_MarginBottom, having type int + ParameterId["MarginBottom"] = "marginBottom"; + // DPI_MarginLeft, having type int + ParameterId["MarginLeft"] = "marginLeft"; + // DPI_MarginRight, having type int + ParameterId["MarginRight"] = "marginRight"; + // DPI_MarginTop, having type int + ParameterId["MarginTop"] = "marginTop"; + // DPI_MaxCell, having type int + ParameterId["MaxCell"] = "maxCell"; + // DPI_MaxItemSpan, having type int + ParameterId["MaxItemSpan"] = "maxItemSpan"; + // DPI_MaxPolynomialDegree, having type int + ParameterId["MaxPolynomialDegree"] = "maxDegree"; + // DPI_MaxPosition, having type int + ParameterId["MaxPosition"] = "maxPosition"; + // DPI_MaxSize, having type int + ParameterId["MaxSize"] = "maxSize"; + // DPI_MinCell, having type int + ParameterId["MinCell"] = "minCell"; + // DPI_MinPolynomialDegree, having type int + ParameterId["MinPolynomialDegree"] = "minDegree"; + // DPI_MinPosition, having type int + ParameterId["MinPosition"] = "minPosition"; + // DPI_MinSize, having type int + ParameterId["MinSize"] = "minSize"; + // DPI_ModelDF, having type int + ParameterId["ModelDF"] = "modelDf"; + // DPI_NewIndex, having type int + ParameterId["NewIndex"] = "newIndex"; + // DPI_NumDataSourcesUsingServer, having type int + ParameterId["NumDataSourcesUsingServer"] = "numDataSourcesUsingServer"; + // DPI_NumFilteredObs, having type int + ParameterId["NumFilteredObs"] = "filteredObservations"; + // DPI_NumModeledObs, having type int + ParameterId["NumModeledObs"] = "modeledObservations"; + // DPI_NumNotClustered, having type int + ParameterId["NumNotClustered"] = "numNotClustered"; + // DPI_NumNumericFields, having type int + ParameterId["NumNumericFields"] = "numNumericFields"; + // DPI_NumOutliers, having type int + ParameterId["NumOutliers"] = "numOutliers"; + // DPI_NumRows, having type int + ParameterId["NumRows"] = "numRows"; + // DPI_NumSelected, having type int + ParameterId["NumSelected"] = "numSelected"; + // DPI_OffsetX, having type int + ParameterId["OffsetX"] = "offsetX"; + // DPI_OffsetY, having type int + ParameterId["OffsetY"] = "offsetY"; + // DPI_Padding, having type int + ParameterId["Padding"] = "padding"; + // DPI_PaddingBottom, having type int + ParameterId["PaddingBottom"] = "paddingBottom"; + // DPI_PaddingLeft, having type int + ParameterId["PaddingLeft"] = "paddingLeft"; + // DPI_PaddingRight, having type int + ParameterId["PaddingRight"] = "paddingRight"; + // DPI_PaddingTop, having type int + ParameterId["PaddingTop"] = "paddingTop"; + // DPI_PageLoadPercentage, having type int + ParameterId["PageLoadPercentage"] = "pageLoadPercentage"; + // DPI_PaletteIndex, having type int + ParameterId["PaletteIndex"] = "paletteIndex"; + // DPI_PaneSpecificationId, having type int + ParameterId["PaneSpecificationId"] = "paneSpec"; + // DPI_ParameterCtrlIncrementsPerTick, having type int + ParameterId["ParameterCtrlIncrementsPerTick"] = "parameterControlIncrementMultiplier"; + // DPI_PolynomialDegree, having type int + ParameterId["PolynomialDegree"] = "degree"; + // DPI_Port, having type int + ParameterId["Port"] = "datasourcePort"; + // DPI_Position, having type int + ParameterId["Position"] = "position"; + // DPI_ParentProjectId, having type int + ParameterId["ParentProjectId"] = "parentProjectId"; + // DPI_Radius, having type int + ParameterId["Radius"] = "radius"; + // DPI_ReadoutOffset, having type int + ParameterId["ReadoutOffset"] = "readoutOffset"; + // DPI_ReferenceIndex, having type int + ParameterId["ReferenceIndex"] = "referenceIndex"; + // DPI_RegionHeight, having type int + ParameterId["RegionHeight"] = "regionHeight"; + // DPI_RegionWidth, having type int + ParameterId["RegionWidth"] = "regionWidth"; + // DPI_RemovedDatasourceCount, having type int + ParameterId["RemovedDatasourceCount"] = "removedDatasourceCount"; + // DPI_RemovedSheetCount, having type int + ParameterId["RemovedSheetCount"] = "removedSheetCount"; + // DPI_ResidualDF, having type int + ParameterId["ResidualDF"] = "residualDf"; + // DPI_ResizeColumn, having type int + ParameterId["ResizeColumn"] = "resizeColumn"; + // DPI_RestartEveryIndex, having type int + ParameterId["RestartEveryIndex"] = "restartEveryIndex"; + // DPI_RightMargin, having type int + ParameterId["RightMargin"] = "rightMargin"; + // DPI_RowCount, having type int + ParameterId["RowCount"] = "rowCount"; + // DPI_RowHeight, having type int + ParameterId["RowHeight"] = "rowHeight"; + // DPI_RowInnerLevels, having type int + ParameterId["RowInnerLevels"] = "rowInnerLevels"; + // DPI_RowLevels, having type int + ParameterId["RowLevels"] = "rowLevels"; + // DPI_RowNumber, having type int + ParameterId["RowNumber"] = "rowNumber"; + // DPI_RowWidth, having type int + ParameterId["RowWidth"] = "rowWidth"; + // DPI_SecondLinkedLevel, having type int + ParameterId["SecondLinkedLevel"] = "secondLinkedLevel"; + // DPI_SecondValueIndex, having type int + ParameterId["SecondValueIndex"] = "secondValueIndex"; + // DPI_SecondsAgo, having type int + ParameterId["SecondsAgo"] = "secondsAgo"; + // DPI_SelectionEnd, having type int + ParameterId["SelectionEnd"] = "selectionEnd"; + // DPI_SelectionStart, having type int + ParameterId["SelectionStart"] = "selectionStart"; + // DPI_ShapePaletteID, having type int + ParameterId["ShapePaletteID"] = "shapePaletteId"; + // DPI_SheetIndex, having type int + ParameterId["SheetIndex"] = "sheetIndex"; + // DPI_ShelfPositionIndex, having type int + ParameterId["ShelfPositionIndex"] = "shelfPosIndex"; + // DPI_Size, having type int + ParameterId["Size"] = "size"; + // DPI_SizeDifference, having type int + ParameterId["SizeDifference"] = "sizeDelta"; + // DPI_SnapDistance, having type int + ParameterId["SnapDistance"] = "snapDistance"; + // DPI_SnapLocation, having type int + ParameterId["SnapLocation"] = "snapLocation"; + // DPI_SolveOrder, having type int + ParameterId["SolveOrder"] = "solveOrder"; + // DPI_SpaceBetweenPoints, having type int + ParameterId["SpaceBetweenPoints"] = "spaceBetweenPoints"; + // DPI_StepSize, having type int + ParameterId["StepSize"] = "stepSize"; + // DPI_Steps, having type int + ParameterId["Steps"] = "steps"; + // DPI_StoryPointIndex, having type int + ParameterId["StoryPointIndex"] = "currentStorypointIndex"; + // DPI_StyleLen, having type int + ParameterId["StyleLen"] = "tokenLengthForStyle"; + // DPI_StylePos, having type int + ParameterId["StylePos"] = "tokenPositionForStyle"; + // DPI_SwatchAreaWidth, having type int + ParameterId["SwatchAreaWidth"] = "swatchWidth"; + // DPI_TargetBinId, having type int + ParameterId["TargetBinId"] = "targetBinId"; + // DPI_TargetPtX, having type int + ParameterId["TargetPtX"] = "targetX"; + // DPI_TargetPtY, having type int + ParameterId["TargetPtY"] = "targetY"; + // DPI_TileFactor, having type int + ParameterId["TileFactor"] = "tileFactor"; + // DPI_TitleHeight, having type int + ParameterId["TitleHeight"] = "titleHeight"; + // DPI_TitleWidth, having type int + ParameterId["TitleWidth"] = "titleWidth"; + // DPI_TopBottomBorderWidth, having type int + ParameterId["TopBottomBorderWidth"] = "topBottomBorderWidth"; + // DPI_UIAutomationLineSize, having type int + ParameterId["UIAutomationLineSize"] = "uiAutomationLineSize"; + // DPI_UIAutomationPageSize, having type int + ParameterId["UIAutomationPageSize"] = "uiAutomationPageSize"; + // DPI_UID, having type int + ParameterId["UID"] = "uid"; + // DPI_UpperBound, having type int + ParameterId["UpperBound"] = "upperBound"; + // DPI_VertTextCell, having type int + ParameterId["VertTextCell"] = "vertTextCell"; + // DPI_Width, having type int + ParameterId["Width"] = "w"; + // DPI_X, having type int + ParameterId["X"] = "x"; + // DPI_Y, having type int + ParameterId["Y"] = "y"; + // DPI_ZOrder, having type int + ParameterId["ZOrder"] = "zOrder"; + // DPI_ZoneIconIndex, having type int + ParameterId["ZoneIconIndex"] = "zoneIconIndex"; + // DPI_AliasIndices, having type int[] + ParameterId["AliasIndices"] = "aliasIndices"; + // DPI_AnovaDFVec, having type int[] + ParameterId["AnovaDFVec"] = "anovaDfVector"; + // DPI_ColumnIndices, having type int[] + ParameterId["ColumnIndices"] = "columnIndices"; + // DPI_DrillFieldIndices, having type int[] + ParameterId["DrillFieldIndices"] = "drillFieldIndices"; + // DPI_FilterMaxIndices, having type int[] + ParameterId["FilterMaxIndices"] = "filterMaxIndices"; + // DPI_FilterMinIndices, having type int[] + ParameterId["FilterMinIndices"] = "filterMinIndices"; + // DPI_FilterValuesIndices, having type int[] + ParameterId["FilterValuesIndices"] = "filterValueIndices"; + // DPI_FormatStringIndices, having type int[] + ParameterId["FormatStringIndices"] = "formatstrIndices"; + // DPI_FormattedValIndices, having type int[] + ParameterId["FormattedValIndices"] = "formatValIdxs"; + // DPI_PaletteIndices, having type int[] + ParameterId["PaletteIndices"] = "palettesIndices"; + // DPI_PaneIndices, having type int[] + ParameterId["PaneIndices"] = "paneIndices"; + // DPI_Points, having type int[] + ParameterId["Points"] = "points"; + // DPI_QuickFilterSettings, having type int[] + ParameterId["QuickFilterSettings"] = "quickFilterSettings"; + // DPI_SelectedIndices, having type int[] + ParameterId["SelectedIndices"] = "selectedIndices"; + // DPI_ShelfPositionIndices, having type int[] + ParameterId["ShelfPositionIndices"] = "shelfPosIndices"; + // DPI_TileBox, having type int[] + ParameterId["TileBox"] = "tileBox"; + // DPI_TrailOverride, having type int[] + ParameterId["TrailOverride"] = "trailOverride"; + // DPI_UIDs, having type int[] + ParameterId["UIDs"] = "uids"; + // DPI_ValueIndices, having type int[] + ParameterId["ValueIndices"] = "valueIndices"; + // DPI_XCellOffsets, having type int[] + ParameterId["XCellOffsets"] = "xCellOffsets"; + // DPI_XPixelOffsets, having type int[] + ParameterId["XPixelOffsets"] = "xPixelOffsets"; + // DPI_YCellOffsets, having type int[] + ParameterId["YCellOffsets"] = "yCellOffsets"; + // DPI_YPixelOffsets, having type int[] + ParameterId["YPixelOffsets"] = "yPixelOffsets"; + // DPI_IntMap, having type Dictionary(of int) + ParameterId["IntMap"] = "intMap"; + // DPI_SelectedAuthSettingIndices, having type Dictionary(of int) + ParameterId["SelectedAuthSettingIndices"] = "selectedAuthSettingIndices"; + // DPI_ActiveStoryPointID, having type uint + ParameterId["ActiveStoryPointID"] = "activeStoryPointId"; + // DPI_ActiveZoneID, having type uint + ParameterId["ActiveZoneID"] = "activeZoneId"; + // DPI_ActualSize, having type uint + ParameterId["ActualSize"] = "actualSize"; + // DPI_AddInDebugPort, having type uint + ParameterId["AddInDebugPort"] = "addInDebugPort"; + // DPI_AggregationIndex, having type uint + ParameterId["AggregationIndex"] = "aggregationIndex"; + // DPI_AnnotationID, having type uint + ParameterId["AnnotationID"] = "annotationId"; + // DPI_AssignedAliasCount, having type uint + ParameterId["AssignedAliasCount"] = "assignedAliasCount"; + // DPI_CapabilityId, having type uint + ParameterId["CapabilityId"] = "capabilityId"; + // DPI_CaretIndex, having type uint + ParameterId["CaretIndex"] = "caretIndex"; + // DPI_CellID, having type uint + ParameterId["CellID"] = "cellId"; + // DPI_ColumnIndex, having type uint + ParameterId["ColumnIndex"] = "columnIndex"; + // DPI_CommandID, having type uint + ParameterId["CommandID"] = "id"; + // DPI_CommandIndex, having type uint + ParameterId["CommandIndex"] = "index"; + // DPI_ControllerId, having type uint + ParameterId["ControllerId"] = "controllerId"; + // DPI_Count, having type uint + ParameterId["Count"] = "count"; + // DPI_URowCount, having type uint + ParameterId["URowCount"] = "uRowCount"; + // DPI_UColumnCount, having type uint + ParameterId["UColumnCount"] = "uColumnCount"; + // DPI_CurrentPage, having type uint + ParameterId["CurrentPage"] = "currentPage"; + // DPI_DatePeriodsCount, having type uint + ParameterId["DatePeriodsCount"] = "datePeriodsCount"; + // DPI_Decimals, having type uint + ParameterId["Decimals"] = "decimals"; + // DPI_DefaultHeight, having type uint + ParameterId["DefaultHeight"] = "defaultHeight"; + // DPI_DefaultItem, having type uint + ParameterId["DefaultItem"] = "defaultItem"; + // DPI_DefaultWidth, having type uint + ParameterId["DefaultWidth"] = "defaultWidth"; + // DPI_Depth, having type uint + ParameterId["Depth"] = "depth"; + // DPI_DetailID, having type uint + ParameterId["DetailID"] = "detailId"; + // DPI_DrillLevel, having type uint + ParameterId["DrillLevel"] = "drillLevel"; + // DPI_DuplicateIndex, having type uint + ParameterId["DuplicateIndex"] = "duplicateIndex"; + // DPI_EndIndex, having type uint + ParameterId["EndIndex"] = "endIndex"; + // DPI_FieldIconIdx, having type uint + ParameterId["FieldIconIdx"] = "fieldIconIdx"; + // DPI_FilterLevel, having type uint + ParameterId["FilterLevel"] = "filterLevel"; + // DPI_FilterTileSize, having type uint + ParameterId["FilterTileSize"] = "filterTileSize"; + // DPI_FiscalYearStart, having type uint + ParameterId["FiscalYearStart"] = "fiscalYearStart"; + // DPI_FitPagesAcross, having type uint + ParameterId["FitPagesAcross"] = "pageFitHorizontal"; + // DPI_FitPagesDown, having type uint + ParameterId["FitPagesDown"] = "pageFitVertical"; + // DPI_FixedIndex, having type uint + ParameterId["FixedIndex"] = "fixedIndex"; + // DPI_FlipboardZoneID, having type uint + ParameterId["FlipboardZoneID"] = "flipboardZoneId"; + // DPI_ForecastAutoRangeSize, having type uint + ParameterId["ForecastAutoRangeSize"] = "forecastAutoRangeSize"; + // DPI_ForecastEndOfRange, having type uint + ParameterId["ForecastEndOfRange"] = "forecastEndOfRange"; + // DPI_ForecastIgnoreLast, having type uint + ParameterId["ForecastIgnoreLast"] = "forecastIgnoreLast"; + // DPI_ForecastNextRangeSize, having type uint + ParameterId["ForecastNextRangeSize"] = "forecastNextRangeSize"; + // DPI_GroupFlags, having type uint + ParameterId["GroupFlags"] = "groupFlag"; + // DPI_HierarchyLevels, having type uint + ParameterId["HierarchyLevels"] = "hierarchyLevels"; + // DPI_HierarchyMemberId, having type uint + ParameterId["HierarchyMemberId"] = "hierarchyMemberId"; + // DPI_HitTestFlags, having type uint + ParameterId["HitTestFlags"] = "hitTestFlags"; + // DPI_ImageHeight, having type uint + ParameterId["ImageHeight"] = "imageHeight"; + // DPI_ImageWidth, having type uint + ParameterId["ImageWidth"] = "imageWidth"; + // DPI_ItemIndex, having type uint + ParameterId["ItemIndex"] = "itemIndex"; + // DPI_ItemIndex1, having type uint + ParameterId["ItemIndex1"] = "itemIndex1"; + // DPI_LineHeight, having type uint + ParameterId["LineHeight"] = "lineHeight"; + // DPI_MapIntermediateLevels, having type uint + ParameterId["MapIntermediateLevels"] = "mapIntermediateLevels"; + // DPI_MapWorldRepeats, having type uint + ParameterId["MapWorldRepeats"] = "mapWorldRepeats"; + // DPI_MaxAlpha, having type uint + ParameterId["MaxAlpha"] = "maxAlpha"; + // DPI_MaxHeight, having type uint + ParameterId["MaxHeight"] = "maxHeight"; + // DPI_MaxNumberWebListItems, having type uint + ParameterId["MaxNumberWebListItems"] = "maxNumberWebListItems"; + // DPI_MaxPrevOrNextValues, having type uint + ParameterId["MaxPrevOrNextValues"] = "maxPrevOrNextValues"; + // DPI_MaxRows, having type uint + ParameterId["MaxRows"] = "maxRows"; + // DPI_MaxTransparency, having type uint + ParameterId["MaxTransparency"] = "colorMaxTransparencyValue"; + // DPI_MaxWidth, having type uint + ParameterId["MaxWidth"] = "maxWidth"; + // DPI_MinColumns, having type uint + ParameterId["MinColumns"] = "minColumns"; + // DPI_MinHeight, having type uint + ParameterId["MinHeight"] = "minHeight"; + // DPI_MinPrevOrNextValues, having type uint + ParameterId["MinPrevOrNextValues"] = "minPrevOrNextValues"; + // DPI_MinTransparency, having type uint + ParameterId["MinTransparency"] = "colorMinTransparencyValue"; + // DPI_MinWidth, having type uint + ParameterId["MinWidth"] = "minWidth"; + // DPI_NestedCalcsIndex, having type uint + ParameterId["NestedCalcsIndex"] = "nestedCalcsIndex"; + // DPI_NextValues, having type uint + ParameterId["NextValues"] = "nextValues"; + // DPI_NodeLevel, having type uint + ParameterId["NodeLevel"] = "nodeLevel"; + // DPI_NumHighlighted, having type uint + ParameterId["NumHighlighted"] = "numHighlighted"; + // DPI_NumberOfNextValues, having type uint + ParameterId["NumberOfNextValues"] = "numberOfNextValues"; + // DPI_NumberOfPrevValues, having type uint + ParameterId["NumberOfPrevValues"] = "numberOfPrevValues"; + // DPI_ObjectID, having type uint + ParameterId["ObjectID"] = "objectId"; + // DPI_OrderingTypeIndex, having type uint + ParameterId["OrderingTypeIndex"] = "orderingTypeIndex"; + // DPI_PageCount, having type uint + ParameterId["PageCount"] = "pageCount"; + // DPI_PageFadeEnd, having type uint + ParameterId["PageFadeEnd"] = "fadeEnd"; + // DPI_PageFadeStart, having type uint + ParameterId["PageFadeStart"] = "fadeStart"; + // DPI_PageIndex, having type uint + ParameterId["PageIndex"] = "pageIndex"; + // DPI_PageNumber, having type uint + ParameterId["PageNumber"] = "pageNumber"; + // DPI_PageScalePercent, having type uint + ParameterId["PageScalePercent"] = "pageScalePercent"; + // DPI_PageTrailLength, having type uint + ParameterId["PageTrailLength"] = "historyLength"; + // DPI_PaletteFlagsVal, having type uint + ParameterId["PaletteFlagsVal"] = "paletteFlagsVal"; + // DPI_PaneIndex, having type uint + ParameterId["PaneIndex"] = "paneIndex"; + // DPI_ParamCtrlDisplayFlags, having type uint + ParameterId["ParamCtrlDisplayFlags"] = "paramDisplayFlags"; + // DPI_ParentZoneID, having type uint + ParameterId["ParentZoneID"] = "parentZoneId"; + // DPI_PercentileParam, having type uint + ParameterId["PercentileParam"] = "percentileParam"; + // DPI_PrevValues, having type uint + ParameterId["PrevValues"] = "prevValues"; + // DPI_PublishResultStringId, having type uint + ParameterId["PublishResultStringId"] = "publishResultStringId"; + // DPI_QRGBColor, having type uint + ParameterId["QRGBColor"] = "qrgbColor"; + // DPI_RangeN, having type uint + ParameterId["RangeN"] = "rangeN"; + // DPI_RankTypeIndex, having type uint + ParameterId["RankTypeIndex"] = "rankTypeIndex"; + // DPI_RenderComplexity, having type uint + ParameterId["RenderComplexity"] = "renderComplexityLimit"; + // DPI_RowIndex, having type uint + ParameterId["RowIndex"] = "rowIndex"; + // DPI_SelectedAuthSettingIndex, having type uint + ParameterId["SelectedAuthSettingIndex"] = "selectedAuthSettingIndex"; + // DPI_SelectedFullScheduleIndex, having type uint + ParameterId["SelectedFullScheduleIndex"] = "selectedFullScheduleIndex"; + // DPI_SelectedIncrScheduleIndex, having type uint + ParameterId["SelectedIncrScheduleIndex"] = "selectedIncrScheduleIndex"; + // DPI_SelectedPublishChoiceIndex, having type uint + ParameterId["SelectedPublishChoiceIndex"] = "selectedPublishChoiceIndex"; + // DPI_SelectedMemberCount, having type uint + ParameterId["SelectedMemberCount"] = "selectedMemberCount"; + // DPI_ShapeID, having type uint + ParameterId["ShapeID"] = "shapeId"; + // DPI_SheetUseCount, having type uint + ParameterId["SheetUseCount"] = "useCount"; + // DPI_ShelfItemID, having type uint + ParameterId["ShelfItemID"] = "shelfItemId"; + // DPI_SigFigs, having type uint + ParameterId["SigFigs"] = "sigFigs"; + // DPI_SortAggIndex, having type uint + ParameterId["SortAggIndex"] = "sortAggIndvValues"; + // DPI_SortColumnIndex, having type uint + ParameterId["SortColumnIndex"] = "sortColumnIndex"; + // DPI_SortDirectionIndex, having type uint + ParameterId["SortDirectionIndex"] = "sortDirectionIndex"; + // DPI_SortFieldIndex, having type uint + ParameterId["SortFieldIndex"] = "sortFieldIndex"; + // DPI_StartIndex, having type uint + ParameterId["StartIndex"] = "startIndex"; + // DPI_StartOfWeek, having type uint + ParameterId["StartOfWeek"] = "startOfWeek"; + // DPI_StoreId, having type uint + ParameterId["StoreId"] = "storeId"; + // DPI_StoryPointID, having type uint + ParameterId["StoryPointID"] = "storyPointId"; + // DPI_TableCalcTypeIndex, having type uint + ParameterId["TableCalcTypeIndex"] = "tableCalcTypeIndex"; + // DPI_TableCalcTypesUsed, having type uint + ParameterId["TableCalcTypesUsed"] = "tableCalcTypesUsed"; + // DPI_TemplateIndex, having type uint + ParameterId["TemplateIndex"] = "templateIndex"; + // DPI_TileCount, having type uint + ParameterId["TileCount"] = "tileCount"; + // DPI_TimeoutSeconds, having type uint + ParameterId["TimeoutSeconds"] = "timeoutSeconds"; + // DPI_TopN, having type uint + ParameterId["TopN"] = "topN"; + // DPI_TotalNumberOfItemsInSet, having type uint + ParameterId["TotalNumberOfItemsInSet"] = "totalNumberOfItemsInSet"; + // DPI_TotalMemberCount, having type uint + ParameterId["TotalMemberCount"] = "totalMemberCount"; + // DPI_Transparency, having type uint + ParameterId["Transparency"] = "colorTransparencyValue"; + // DPI_TupleID, having type uint + ParameterId["TupleID"] = "tupleId"; + // DPI_UIndex, having type uint + ParameterId["UIndex"] = "uindex"; + // DPI_UndoPosition, having type uint + ParameterId["UndoPosition"] = "undoPosition"; + // DPI_UnsignedWidth, having type uint + ParameterId["UnsignedWidth"] = "uw"; + // DPI_UnsignedWidthBottom, having type uint + ParameterId["UnsignedWidthBottom"] = "uwb"; + // DPI_UnsignedWidthLeft, having type uint + ParameterId["UnsignedWidthLeft"] = "uwl"; + // DPI_UnsignedWidthRight, having type uint + ParameterId["UnsignedWidthRight"] = "uwr"; + // DPI_UnsignedWidthTop, having type uint + ParameterId["UnsignedWidthTop"] = "uwt"; + // DPI_ValueIndex, having type uint + ParameterId["ValueIndex"] = "valueIndex"; + // DPI_ValueInt, having type uint + ParameterId["ValueInt"] = "valueInt"; + // DPI_WorldOffset, having type uint + ParameterId["WorldOffset"] = "worldOffset"; + // DPI_XDuplicateIndex, having type uint + ParameterId["XDuplicateIndex"] = "xDuplicateIndex"; + // DPI_XIndex, having type uint + ParameterId["XIndex"] = "xIndex"; + // DPI_YDuplicateIndex, having type uint + ParameterId["YDuplicateIndex"] = "yDuplicateIndex"; + // DPI_YIndex, having type uint + ParameterId["YIndex"] = "yIndex"; + // DPI_ZoneID, having type uint + ParameterId["ZoneID"] = "zoneId"; + // DPI_ZoneZOrder, having type uint + ParameterId["ZoneZOrder"] = "zoneZOrder"; + // DPI_ComponentID, having type uint + ParameterId["ComponentID"] = "componentId"; + // DPI_NonThreadPoolUseCount, having type uint + ParameterId["NonThreadPoolUseCount"] = "nonThreadPoolUseCount"; + // DPI_AddressingIndices, having type uint[] + ParameterId["AddressingIndices"] = "addressingIndices"; + // DPI_AddressingInvalidIndices, having type uint[] + ParameterId["AddressingInvalidIndices"] = "addressingInvalidIndices"; + // DPI_ChildZoneIds, having type uint[] + ParameterId["ChildZoneIds"] = "childZoneIds"; + // DPI_ColorList, having type uint[] + ParameterId["ColorList"] = "colorList"; + // DPI_DuplicateIndices, having type uint[] + ParameterId["DuplicateIndices"] = "duplicateIndices"; + // DPI_FilterAddIndices, having type uint[] + ParameterId["FilterAddIndices"] = "filterAddIndices"; + // DPI_FilterIndices, having type uint[] + ParameterId["FilterIndices"] = "filterIndices"; + // DPI_FilterLevelAdd, having type uint[] + ParameterId["FilterLevelAdd"] = "filterLevelAdd"; + // DPI_FilterLevelRemove, having type uint[] + ParameterId["FilterLevelRemove"] = "filterLevelRemove"; + // DPI_FilterLevels, having type uint[] + ParameterId["FilterLevels"] = "filterLevels"; + // DPI_FilterRemoveIndices, having type uint[] + ParameterId["FilterRemoveIndices"] = "filterRemoveIndices"; + // DPI_FixedValues, having type uint[] + ParameterId["FixedValues"] = "fixedValues"; + // DPI_HierarchyMemberIdList, having type uint[] + ParameterId["HierarchyMemberIdList"] = "hierarchyMemberIdList"; + // DPI_InvalidIndices, having type uint[] + ParameterId["InvalidIndices"] = "invalidIndices"; + // DPI_ItemIndices, having type uint[] + ParameterId["ItemIndices"] = "itemIndices"; + // DPI_LineTupleIDs, having type uint[] + ParameterId["LineTupleIDs"] = "lineTupleIds"; + // DPI_ObjectIDs, having type uint[] + ParameterId["ObjectIDs"] = "objectIds"; + // DPI_PageIndices, having type uint[] + ParameterId["PageIndices"] = "pageIndices"; + // DPI_QRGB, having type uint[] + ParameterId["QRGB"] = "qrgbList"; + // DPI_QRGBColors, having type uint[] + ParameterId["QRGBColors"] = "qrgbColors"; + // DPI_RefLineID, having type uint[] + ParameterId["RefLineID"] = "reflineId"; + // DPI_ShapeIDs, having type uint[] + ParameterId["ShapeIDs"] = "shapeIds"; + // DPI_ShelfSelection, having type uint[] + ParameterId["ShelfSelection"] = "shelfSelection"; + // DPI_StoryPointIDs, having type uint[] + ParameterId["StoryPointIDs"] = "storyPointIds"; + // DPI_TupleIDs, having type uint[] + ParameterId["TupleIDs"] = "tupleIds"; + // DPI_Widths, having type uint[] + ParameterId["Widths"] = "widths"; + // DPI_UintMap, having type Dictionary(of uint32_t) + ParameterId["UintMap"] = "uintMap"; + // DPI_Alpha, having type float + ParameterId["Alpha"] = "alpha"; + // DPI_Angle, having type float + ParameterId["Angle"] = "angle"; + // DPI_BreakPointValue, having type float + ParameterId["BreakPointValue"] = "breakPointValue"; + // DPI_DevicePixelRatio, having type float + ParameterId["DevicePixelRatio"] = "devicePixelRatio"; + // DPI_Distance, having type float + ParameterId["Distance"] = "distance"; + // DPI_FloatX, having type float + ParameterId["FloatX"] = "floatX"; + // DPI_FloatY, having type float + ParameterId["FloatY"] = "floatY"; + // DPI_FogDesaturation, having type float + ParameterId["FogDesaturation"] = "fogDesaturation"; + // DPI_MarkScale, having type float + ParameterId["MarkScale"] = "markScale"; + // DPI_MarkSizeInPixelUnits, having type float + ParameterId["MarkSizeInPixelUnits"] = "markSizeInPixelUnits"; + // DPI_PointSize, having type float + ParameterId["PointSize"] = "pointSize"; + // DPI_StrokeWidth, having type float + ParameterId["StrokeWidth"] = "strokeWidth"; + // DPI_TextRegionOrientation, having type float + ParameterId["TextRegionOrientation"] = "orientation"; + // DPI_TransformAngle, having type float + ParameterId["TransformAngle"] = "transformAngle"; + // DPI_ZoomLevel, having type float + ParameterId["ZoomLevel"] = "zoomLevel"; + // DPI_OldZoomLevel, having type float + ParameterId["OldZoomLevel"] = "oldZoomLevel"; + // DPI_NewZoomLevel, having type float + ParameterId["NewZoomLevel"] = "newZoomLevel"; + // DPI_AspectRatio, having type float + ParameterId["AspectRatio"] = "aspectRatio"; + // DPI_BottomPrintMargin, having type float + ParameterId["BottomPrintMargin"] = "bottomPrintMargin"; + // DPI_EarthRadius, having type float + ParameterId["EarthRadius"] = "earthRadius"; + // DPI_FloatHeight, having type float + ParameterId["FloatHeight"] = "floatHeight"; + // DPI_FloatLeft, having type float + ParameterId["FloatLeft"] = "floatLeft"; + // DPI_FloatRadius, having type float + ParameterId["FloatRadius"] = "floatRadius"; + // DPI_FloatTop, having type float + ParameterId["FloatTop"] = "floatTop"; + // DPI_FloatWidth, having type float + ParameterId["FloatWidth"] = "floatWidth"; + // DPI_LeftPrintMargin, having type float + ParameterId["LeftPrintMargin"] = "leftPrintMargin"; + // DPI_MapCenterLatitude, having type float + ParameterId["MapCenterLatitude"] = "mapCenterLatitude"; + // DPI_MapCenterLongitude, having type float + ParameterId["MapCenterLongitude"] = "mapCenterLongitude"; + // DPI_MapDisplayScale, having type float + ParameterId["MapDisplayScale"] = "mapDisplayScale"; + // DPI_MapMaxStretch, having type float + ParameterId["MapMaxStretch"] = "mapMaxStretch"; + // DPI_MapMaxZoom, having type float + ParameterId["MapMaxZoom"] = "mapMaxZoom"; + // DPI_MapMinShrink, having type float + ParameterId["MapMinShrink"] = "mapMinShrink"; + // DPI_MapMinZoom, having type float + ParameterId["MapMinZoom"] = "mapMinZoom"; + // DPI_MapRequestZoom, having type float + ParameterId["MapRequestZoom"] = "mapRequestZoom"; + // DPI_MapWashout, having type float + ParameterId["MapWashout"] = "mapWashout"; + // DPI_MaxLatitude, having type float + ParameterId["MaxLatitude"] = "maxLatitude"; + // DPI_MaxLongitude, having type float + ParameterId["MaxLongitude"] = "maxLongitude"; + // DPI_MinLatitude, having type float + ParameterId["MinLatitude"] = "minLatitude"; + // DPI_MinLongitude, having type float + ParameterId["MinLongitude"] = "minLongitude"; + // DPI_RightPrintMargin, having type float + ParameterId["RightPrintMargin"] = "rightPrintMargin"; + // DPI_TopPrintMargin, having type float + ParameterId["TopPrintMargin"] = "topPrintMargin"; + // DPI_UIAutomationMaximum, having type float + ParameterId["UIAutomationMaximum"] = "uiAutomationMaximum"; + // DPI_UIAutomationMinimum, having type float + ParameterId["UIAutomationMinimum"] = "uiAutomationMinimum"; + // DPI_UIAutomationOffset, having type float + ParameterId["UIAutomationOffset"] = "uiAutomationOffset"; + // DPI_UnitDivisor, having type float + ParameterId["UnitDivisor"] = "unitDivisor"; + // DPI_UnitTransition, having type float + ParameterId["UnitTransition"] = "unitTransition"; + // DPI_AutomaticDrillIdx, having type float[] + ParameterId["AutomaticDrillIdx"] = "automaticDrillIdx"; + // DPI_DestinationBox, having type float[] + ParameterId["DestinationBox"] = "destBox"; + // DPI_LowerEnd, having type float[] + ParameterId["LowerEnd"] = "lowerEnd"; + // DPI_OppositeAxis, having type float[] + ParameterId["OppositeAxis"] = "oppositeAxis"; + // DPI_PointsF, having type float[] + ParameterId["PointsF"] = "pointsF"; + // DPI_SourceBox, having type float[] + ParameterId["SourceBox"] = "sourceBox"; + // DPI_TransformOffset, having type float[] + ParameterId["TransformOffset"] = "transformOffset"; + // DPI_TransformScale, having type float[] + ParameterId["TransformScale"] = "transformScale"; + // DPI_UpperEnd, having type float[] + ParameterId["UpperEnd"] = "upperEnd"; + // DPI_FloatMap, having type Dictionary(of float) + ParameterId["FloatMap"] = "floatMap"; + // DPI_BGSS, having type double + ParameterId["BGSS"] = "betweenGroupSumOfSquares"; + // DPI_ConfidenceLevel, having type double + ParameterId["ConfidenceLevel"] = "confidenceLevel"; + // DPI_ConfidencePercentage, having type double + ParameterId["ConfidencePercentage"] = "confidencePercentage"; + // DPI_DoubleLeft, having type double + ParameterId["DoubleLeft"] = "doubleLeft"; + // DPI_DoubleTop, having type double + ParameterId["DoubleTop"] = "doubleTop"; + // DPI_DoubleValue, having type double + ParameterId["DoubleValue"] = "doubleValue"; + // DPI_DoubleX, having type double + ParameterId["DoubleX"] = "doubleX"; + // DPI_DoubleY, having type double + ParameterId["DoubleY"] = "doubleY"; + // DPI_FStatistic, having type double + ParameterId["FStatistic"] = "fStatistic"; + // DPI_FilterRangeMax, having type double + ParameterId["FilterRangeMax"] = "filterRangeMax"; + // DPI_FilterRangeMin, having type double + ParameterId["FilterRangeMin"] = "filterRangeMin"; + // DPI_GeographicSearchCandidateScore, having type double + ParameterId["GeographicSearchCandidateScore"] = "geographicSearchCandidateScore"; + // DPI_HeightD, having type double + ParameterId["HeightD"] = "height"; + // DPI_InflectionFraction, having type double + ParameterId["InflectionFraction"] = "inflectionFraction"; + // DPI_InflectionValue, having type double + ParameterId["InflectionValue"] = "inflectionValue"; + // DPI_MSE, having type double + ParameterId["MSE"] = "meanSquaredError"; + // DPI_MSM, having type double + ParameterId["MSM"] = "meanSquaredModel"; + // DPI_MapScaleMarginOfError, having type double + ParameterId["MapScaleMarginOfError"] = "mapScaleMarginOfError"; + // DPI_MarkSize, having type double + ParameterId["MarkSize"] = "markSize"; + // DPI_MaxMarkSize, having type double + ParameterId["MaxMarkSize"] = "maxMarkSize"; + // DPI_MinMarkSize, having type double + ParameterId["MinMarkSize"] = "minMarkSize"; + // DPI_NotchPosition, having type double + ParameterId["NotchPosition"] = "notchPosition"; + // DPI_NotchValue, having type double + ParameterId["NotchValue"] = "notchValue"; + // DPI_PValue, having type double + ParameterId["PValue"] = "pValue"; + // DPI_PercentDimensions, having type double + ParameterId["PercentDimensions"] = "percentDimensions"; + // DPI_PercentGroups, having type double + ParameterId["PercentGroups"] = "percentGroups"; + // DPI_PercentMeasures, having type double + ParameterId["PercentMeasures"] = "percentMeasures"; + // DPI_RSquared, having type double + ParameterId["RSquared"] = "rSquared"; + // DPI_SSE, having type double + ParameterId["SSE"] = "sumSquaredError"; + // DPI_SSM, having type double + ParameterId["SSM"] = "sumSquaredModel"; + // DPI_StandardError, having type double + ParameterId["StandardError"] = "standardError"; + // DPI_TSS, having type double + ParameterId["TSS"] = "totalSumOfSquares"; + // DPI_WGSS, having type double + ParameterId["WGSS"] = "withinGroupSumOfSquares"; + // DPI_WidthD, having type double + ParameterId["WidthD"] = "width"; + // DPI_ZoomFactor, having type double + ParameterId["ZoomFactor"] = "zoomFactor"; + // DPI_CoefficientPValueVec, having type double[] + ParameterId["CoefficientPValueVec"] = "coefficientPValueVector"; + // DPI_CoefficientStdErrVec, having type double[] + ParameterId["CoefficientStdErrVec"] = "coefficientStdErrorVector"; + // DPI_CoefficientTValueVec, having type double[] + ParameterId["CoefficientTValueVec"] = "coefficientTValueVector"; + // DPI_CoefficientVec, having type double[] + ParameterId["CoefficientVec"] = "coefficientVector"; + // DPI_FStatisticVec, having type double[] + ParameterId["FStatisticVec"] = "trendLineFStatisticVector"; + // DPI_Factors, having type double[] + ParameterId["Factors"] = "factors"; + // DPI_MSEVec, having type double[] + ParameterId["MSEVec"] = "meanSquaredErrorVector"; + // DPI_Means, having type double[] + ParameterId["Means"] = "means"; + // DPI_PValueVec, having type double[] + ParameterId["PValueVec"] = "pValueVector"; + // DPI_Percentages, having type double[] + ParameterId["Percentages"] = "percentages"; + // DPI_Percentiles, having type double[] + ParameterId["Percentiles"] = "percentiles"; + // DPI_SSEVec, having type double[] + ParameterId["SSEVec"] = "sumSquaredErrorVector"; + // DPI_StDevs, having type double[] + ParameterId["StDevs"] = "stdev"; + // DPI_UnscaledMeans, having type double[] + ParameterId["UnscaledMeans"] = "unscaledMeans"; + // DPI_DeltaTimeMs, having type long + ParameterId["DeltaTimeMs"] = "deltaTimeMs"; + // DPI_ExtractHistoryRowCount, having type long + ParameterId["ExtractHistoryRowCount"] = "extractRowCount"; + // DPI_ExtractHistoryRowsRemoved, having type long + ParameterId["ExtractHistoryRowsRemoved"] = "extractRowsRemoved"; + // DPI_ExtractsSize, having type long + ParameterId["ExtractsSize"] = "extractsSize"; + // DPI_OldExtractSize, having type long + ParameterId["OldExtractSize"] = "oldExtractSize"; + // DPI_RowsInserted, having type long + ParameterId["RowsInserted"] = "rowsInserted"; + // DPI_SampleSize, having type long + ParameterId["SampleSize"] = "sampleSize"; + // DPI_SampleSpace, having type long + ParameterId["SampleSpace"] = "sampleSpace"; + // DPI_ThreadPoolUseCount, having type long + ParameterId["ThreadPoolUseCount"] = "threadPoolUseCount"; + // DPI_ActionId, having type string + ParameterId["ActionId"] = "actionId"; + // DPI_AxisColumn, having type string + ParameterId["AxisColumn"] = "axisColumn"; + // DPI_BaseColumnName, having type string + ParameterId["BaseColumnName"] = "baseColumnName"; + // DPI_BreakPointFieldName, having type string + ParameterId["BreakPointFieldName"] = "breakPointFieldName"; + // DPI_PairedFieldName, having type string + ParameterId["PairedFieldName"] = "pairedFn"; + // DPI_FieldNameAllowEmpty, having type string + ParameterId["FieldNameAllowEmpty"] = "fieldNameAllowEmpty"; + // DPI_FieldNameDisAgg, having type string + ParameterId["FieldNameDisAgg"] = "fnDisagg"; + // DPI_FieldNameLocal, having type string + ParameterId["FieldNameLocal"] = "fieldNameLocal"; + // DPI_FieldNamePrev, having type string + ParameterId["FieldNamePrev"] = "fnPrev"; + // DPI_FieldNameSource, having type string + ParameterId["FieldNameSource"] = "fnSource"; + // DPI_FieldNameTarget, having type string + ParameterId["FieldNameTarget"] = "fnTarget"; + // DPI_FieldNameX, having type string + ParameterId["FieldNameX"] = "fnX"; + // DPI_FieldNameY, having type string + ParameterId["FieldNameY"] = "fnY"; + // DPI_FieldToSort, having type string + ParameterId["FieldToSort"] = "fieldToSort"; + // DPI_GlobalFieldName, having type string + ParameterId["GlobalFieldName"] = "globalFieldName"; + // DPI_HierarchyName, having type string + ParameterId["HierarchyName"] = "hierarchyName"; + // DPI_InvalidAggFieldName, having type string + ParameterId["InvalidAggFieldName"] = "invalidAggFieldName"; + // DPI_InvalidFieldName, having type string + ParameterId["InvalidFieldName"] = "invalidFieldName"; + // DPI_LimitParameterName, having type string + ParameterId["LimitParameterName"] = "limitParameterName"; + // DPI_LocalBaseColumnName, having type string + ParameterId["LocalBaseColumnName"] = "localBaseColumnName"; + // DPI_MeasureName, having type string + ParameterId["MeasureName"] = "measureName"; + // DPI_NestedCalcField, having type string + ParameterId["NestedCalcField"] = "nestedCalcFn"; + // DPI_ParameterName, having type string + ParameterId["ParameterName"] = "parameterName"; + // DPI_ReferenceParam, having type string + ParameterId["ReferenceParam"] = "referenceParam"; + // DPI_ReplacementFieldName, having type string + ParameterId["ReplacementFieldName"] = "replacementFieldName"; + // DPI_RHSTableAlias, having type string + ParameterId["RHSTableAlias"] = "rhsTableAlias"; + // DPI_SortMeasureName, having type string + ParameterId["SortMeasureName"] = "sortMeasureName"; + // DPI_UniqueName, having type string + ParameterId["UniqueName"] = "uniqueName"; + // DPI_ValueColumn, having type string + ParameterId["ValueColumn"] = "valueColumn"; + // DPI_PairedValueColumn, having type string + ParameterId["PairedValueColumn"] = "pairedValueColumn"; + // DPI_ActionIds, having type string[] + ParameterId["ActionIds"] = "actionIds"; + // DPI_AddressingValues, having type string[] + ParameterId["AddressingValues"] = "addressingValues"; + // DPI_AllColumns, having type string[] + ParameterId["AllColumns"] = "allColumns"; + // DPI_AtTheLevelValues, having type string[] + ParameterId["AtTheLevelValues"] = "atTheLevelValues"; + // DPI_AutomaticDrillFieldName, having type string[] + ParameterId["AutomaticDrillFieldName"] = "automaticDrillFieldName"; + // DPI_BlendingFieldCandidates, having type string[] + ParameterId["BlendingFieldCandidates"] = "blendingFieldCandidates"; + // DPI_Columns, having type string[] + ParameterId["Columns"] = "columns"; + // DPI_CurrentBlendingFields, having type string[] + ParameterId["CurrentBlendingFields"] = "currentBlendingFields"; + // DPI_DimensionsToSort, having type string[] + ParameterId["DimensionsToSort"] = "dimensionsToSort"; + // DPI_DrillFieldVector, having type string[] + ParameterId["DrillFieldVector"] = "drillFieldVector"; + // DPI_EncodingFieldVector, having type string[] + ParameterId["EncodingFieldVector"] = "encodingFieldVector"; + // DPI_FieldVector, having type string[] + ParameterId["FieldVector"] = "fieldVector"; + // DPI_FilterFields, having type string[] + ParameterId["FilterFields"] = "filterFields"; + // DPI_LODFieldVector, having type string[] + ParameterId["LODFieldVector"] = "lodFieldVector"; + // DPI_LegendColumns, having type string[] + ParameterId["LegendColumns"] = "legendColumns"; + // DPI_LegendNames, having type string[] + ParameterId["LegendNames"] = "legendNames"; + // DPI_NodeColumns, having type string[] + ParameterId["NodeColumns"] = "nodeColumns"; + // DPI_PageFields, having type string[] + ParameterId["PageFields"] = "pageFields"; + // DPI_ParamValues, having type string[] + ParameterId["ParamValues"] = "paramValues"; + // DPI_RefLineFields, having type string[] + ParameterId["RefLineFields"] = "reflineFields"; + // DPI_ReferencedColumns, having type string[] + ParameterId["ReferencedColumns"] = "referencedColumns"; + // DPI_RelatedFieldNames, having type string[] + ParameterId["RelatedFieldNames"] = "relatedFieldNames"; + // DPI_RemoveActionResults, having type string[] + ParameterId["RemoveActionResults"] = "removeActionResults"; + // DPI_ResponseVector, having type string[] + ParameterId["ResponseVector"] = "responseVector"; + // DPI_RestartEveryValues, having type string[] + ParameterId["RestartEveryValues"] = "restartEveryValues"; + // DPI_ResultFields, having type string[] + ParameterId["ResultFields"] = "resultFields"; + // DPI_SortFieldValues, having type string[] + ParameterId["SortFieldValues"] = "sortFieldValues"; + // DPI_XFields, having type string[] + ParameterId["XFields"] = "xFields"; + // DPI_YFields, having type string[] + ParameterId["YFields"] = "yFields"; + // DPI_ConnectionFullName, having type string + ParameterId["ConnectionFullName"] = "connectionFullName"; + // DPI_ConnectionFullNames, having type string[] + ParameterId["ConnectionFullNames"] = "connectionFullNames"; + // DPI_BoundDataValue, having type object + ParameterId["BoundDataValue"] = "boundDataValue"; + // DPI_DataValue, having type object + ParameterId["DataValue"] = "dataValue"; + // DPI_DataValueIncrement, having type object + ParameterId["DataValueIncrement"] = "dataValueIncrement"; + // DPI_DataValueLowerX, having type object + ParameterId["DataValueLowerX"] = "dataValueLowerX"; + // DPI_DataValueLowerY, having type object + ParameterId["DataValueLowerY"] = "dataValueLowerY"; + // DPI_DataValueUpperX, having type object + ParameterId["DataValueUpperX"] = "dataValueUpperX"; + // DPI_DataValueUpperY, having type object + ParameterId["DataValueUpperY"] = "dataValueUpperY"; + // DPI_DefaultDataValue, having type object + ParameterId["DefaultDataValue"] = "defaultDataValue"; + // DPI_MaxDataValue, having type object + ParameterId["MaxDataValue"] = "maxDataValue"; + // DPI_MinDataValue, having type object + ParameterId["MinDataValue"] = "minDataValue"; + // DPI_ValidatedDataValue, having type object + ParameterId["ValidatedDataValue"] = "validatedDataValue"; + // DPI_BinSize, having type object + ParameterId["BinSize"] = "binSize"; + // DPI_LimitCount, having type object + ParameterId["LimitCount"] = "limitCount"; + // DPI_DataValueList, having type object[] + ParameterId["DataValueList"] = "dataValueList"; + // DPI_FieldDisplayItem, having type FieldDisplayItemPresModel + ParameterId["FieldDisplayItem"] = "fieldDisplayItem"; + // DPI_FieldDisplayList, having type FieldDisplayItemPresModel[] + ParameterId["FieldDisplayList"] = "fieldDisplayList"; + // DPI_FieldCaptionPair, having type FieldCaptionPairPresModel + ParameterId["FieldCaptionPair"] = "fieldCaptionPair"; + // DPI_FieldCaptionPairs, having type FieldCaptionPairPresModel[] + ParameterId["FieldCaptionPairs"] = "fieldCaptionPairs"; + // DPI_ParameterCaptionPairs, having type FieldCaptionPairPresModel[] + ParameterId["ParameterCaptionPairs"] = "parameterCaptionPairs"; + // DPI_VaryingAttributeDimensions, having type FieldCaptionPairPresModel[] + ParameterId["VaryingAttributeDimensions"] = "varyingAttributeDimensions"; + // DPI_FieldCaptionPairState, having type FieldCaptionPairStatePresModel + ParameterId["FieldCaptionPairState"] = "fieldCaptionPairState"; + // DPI_FieldCaptionPairStates, having type FieldCaptionPairStatePresModel[] + ParameterId["FieldCaptionPairStates"] = "fieldCaptionPairStates"; + // DPI_DatasourceCaptionPair, having type DatasourceCaptionPairPresModel + ParameterId["DatasourceCaptionPair"] = "datasourceCaptionPair"; + // DPI_DatasourceCaptionPairs, having type DatasourceCaptionPairPresModel[] + ParameterId["DatasourceCaptionPairs"] = "datasourceCaptionPairs"; + // DPI_SheetNameInfoPair, having type SheetNameInfoPairPresModel + ParameterId["SheetNameInfoPair"] = "sheetNameInfoPair"; + // DPI_SheetNameInfoPairs, having type SheetNameInfoPairPresModel[] + ParameterId["SheetNameInfoPairs"] = "sheetNameInfoPairs"; + // DPI_BGActiveColor, having type string + ParameterId["BGActiveColor"] = "bgActiveColor"; + // DPI_BGColor, having type string + ParameterId["BGColor"] = "bgColor"; + // DPI_BGRestColor, having type string + ParameterId["BGRestColor"] = "bgRestColor"; + // DPI_BorderColor, having type string + ParameterId["BorderColor"] = "borderColor"; + // DPI_BorderColorBottom, having type string + ParameterId["BorderColorBottom"] = "borderColorBottom"; + // DPI_BorderColorLeft, having type string + ParameterId["BorderColorLeft"] = "borderColorLeft"; + // DPI_BorderColorRight, having type string + ParameterId["BorderColorRight"] = "borderColorRight"; + // DPI_BorderColorTop, having type string + ParameterId["BorderColorTop"] = "borderColorTop"; + // DPI_ButtonObjectBackgroundColor, having type string + ParameterId["ButtonObjectBackgroundColor"] = "buttonObjectBackgroundColor"; + // DPI_Color, having type string + ParameterId["Color"] = "color"; + // DPI_Color1, having type string + ParameterId["Color1"] = "color1"; + // DPI_Color2, having type string + ParameterId["Color2"] = "color2"; + // DPI_DefaultColor, having type string + ParameterId["DefaultColor"] = "defaultColor"; + // DPI_DistanceFontColor, having type string + ParameterId["DistanceFontColor"] = "distanceFontColor"; + // DPI_FillColor, having type string + ParameterId["FillColor"] = "fillColor"; + // DPI_FogColor, having type string + ParameterId["FogColor"] = "fogColor"; + // DPI_HeaderColor, having type string + ParameterId["HeaderColor"] = "headerColor"; + // DPI_HighlightBGColor, having type string + ParameterId["HighlightBGColor"] = "highlightBgColor"; + // DPI_HighlightTextColor, having type string + ParameterId["HighlightTextColor"] = "highlightTextColor"; + // DPI_HoverColor, having type string + ParameterId["HoverColor"] = "hoverColor"; + // DPI_HyperlinkColor, having type string + ParameterId["HyperlinkColor"] = "hyperlinkColor"; + // DPI_MapAttributionFill, having type string + ParameterId["MapAttributionFill"] = "mapAttributionFill"; + // DPI_MapAttributionTextColor, having type string + ParameterId["MapAttributionTextColor"] = "mapAttributionTextColor"; + // DPI_MapPaneBackgroundFill, having type string + ParameterId["MapPaneBackgroundFill"] = "mapPaneBackgroundFill"; + // DPI_MapScaleBorderColor, having type string + ParameterId["MapScaleBorderColor"] = "mapScaleBorderColor"; + // DPI_MapScaleColor, having type string + ParameterId["MapScaleColor"] = "mapScaleColor"; + // DPI_MapWaitTileFill, having type string + ParameterId["MapWaitTileFill"] = "mapWaitTileFill"; + // DPI_MarkColor, having type string + ParameterId["MarkColor"] = "markColor"; + // DPI_NavArrowDisabledColor, having type string + ParameterId["NavArrowDisabledColor"] = "navArrowDisabledColor"; + // DPI_NavArrowHoverColor, having type string + ParameterId["NavArrowHoverColor"] = "navArrowHoverColor"; + // DPI_NavArrowIdleColor, having type string + ParameterId["NavArrowIdleColor"] = "navArrowIdleColor"; + // DPI_NavArrowPressedColor, having type string + ParameterId["NavArrowPressedColor"] = "navArrowPressedColor"; + // DPI_PaneColor, having type string + ParameterId["PaneColor"] = "paneColor"; + // DPI_PressColor, having type string + ParameterId["PressColor"] = "pressColor"; + // DPI_ResizeBorderColor, having type string + ParameterId["ResizeBorderColor"] = "resizeBorderColor"; + // DPI_SelectBGColor, having type string + ParameterId["SelectBGColor"] = "selectBgColor"; + // DPI_SelectionTextColor, having type string + ParameterId["SelectionTextColor"] = "selectionTextColor"; + // DPI_SwatchBackgroundColor, having type string + ParameterId["SwatchBackgroundColor"] = "swatchBgColor"; + // DPI_SwatchBorderColor, having type string + ParameterId["SwatchBorderColor"] = "swatchBorderColor"; + // DPI_TabColor, having type string + ParameterId["TabColor"] = "tabColor"; + // DPI_Colors, having type string[] + ParameterId["Colors"] = "colors"; + // DPI_ColorMap, having type Dictionary(of string) + ParameterId["ColorMap"] = "colorMap"; + // DPI_Pixmap, having type string + ParameterId["Pixmap"] = "pixmap"; + // DPI_Image, having type string + ParameterId["Image"] = "image"; + // DPI_OverlayImage, having type string + ParameterId["OverlayImage"] = "overlayImage"; + // DPI_IconImage, having type string + ParameterId["IconImage"] = "iconImage"; + // DPI_ImageList, having type string[] + ParameterId["ImageList"] = "imageList"; + // DPI_ImageMap, having type Dictionary(of string) + ParameterId["ImageMap"] = "imageMap"; + // DPI_UUID, having type object + ParameterId["UUID"] = "uuid"; + // DPI_DashboardObjectHandle, having type object + ParameterId["DashboardObjectHandle"] = "dashboardObjectHandle"; + // DPI_DashboardObjectNewStateHandle, having type object + ParameterId["DashboardObjectNewStateHandle"] = "dashboardObjectNewStateHandle"; + // DPI_DashboardObjectCurrentStateHandle, having type object + ParameterId["DashboardObjectCurrentStateHandle"] = "dashboardObjectCurrentStateHandle"; + // DPI_Nanoseconds, having type object + ParameterId["Nanoseconds"] = "nanoseconds"; + // DPI_Microseconds, having type object + ParameterId["Microseconds"] = "microseconds"; + // DPI_Milliseconds, having type object + ParameterId["Milliseconds"] = "milliseconds"; + // DPI_TimeoutS, having type object + ParameterId["TimeoutS"] = "timeoutS"; + // DPI_Minutes, having type object + ParameterId["Minutes"] = "minutes"; + // DPI_Hours, having type object + ParameterId["Hours"] = "hours"; + // DPI_CardType, having type CardType + ParameterId["CardType"] = "cardType"; + // DPI_DocParameterID, having type string + ParameterId["DocParameterID"] = "type"; + // DPI_ArgumentParam, having type string + ParameterId["ArgumentParam"] = "argumentParam"; + // DPI_ArgumentParams, having type string[] + ParameterId["ArgumentParams"] = "argumentParams"; + // DPI_ActionType, having type ActionType + ParameterId["ActionType"] = "actionType"; + // DPI_AnnotateEnum, having type AnnotateEnum + ParameterId["AnnotateEnum"] = "annotateEnum"; + // DPI_JoinType, having type SQLJoinType + ParameterId["JoinType"] = "joinType"; + // DPI_SupportedJoinTypes, having type SQLJoinType[] + ParameterId["SupportedJoinTypes"] = "supportedJoinTypes"; + // DPI_Rounding, having type Rounding + ParameterId["Rounding"] = "roundingEnum"; + // DPI_BodyType, having type BodyType + ParameterId["BodyType"] = "bodyType"; + // DPI_LineEnd, having type LineEnd + ParameterId["LineEnd"] = "lineEndEnum"; + // DPI_LineEndSize, having type LineEndSize + ParameterId["LineEndSize"] = "lineEndSizeEnum"; + // DPI_BrushSpecialFields, having type BrushSpecialFields + ParameterId["BrushSpecialFields"] = "specialFields"; + // DPI_CellSizeChange, having type CellSizeChange + ParameterId["CellSizeChange"] = "cellSizeChange"; + // DPI_CellType, having type CellType + ParameterId["CellType"] = "cellType"; + // DPI_ConnectionAttemptResult, having type ConnectionAttemptResult + ParameterId["ConnectionAttemptResult"] = "connectionAttemptResult"; + // DPI_ConnectionErrorStage, having type ConnectionErrorStage + ParameterId["ConnectionErrorStage"] = "connectionErrorStage"; + // DPI_ConnectionErrorType, having type ConnectionErrorType + ParameterId["ConnectionErrorType"] = "connectionErrorType"; + // DPI_DataServerConnectionResult, having type DataServerConnectionResult + ParameterId["DataServerConnectionResult"] = "dsConnectionResult"; + // DPI_DropWhen, having type DropWhen + ParameterId["DropWhen"] = "dropWhen"; + // DPI_DropType, having type DropFieldResult + ParameterId["DropType"] = "dropType"; + // DPI_EncodingType, having type EncodingType + ParameterId["EncodingType"] = "encodingType"; + // DPI_DropdownEncodingType, having type EncodingType + ParameterId["DropdownEncodingType"] = "dropdownEncodingType"; + // DPI_EncodingTypes, having type EncodingType[] + ParameterId["EncodingTypes"] = "encodingTypes"; + // DPI_FieldOrderType, having type FieldOrderType + ParameterId["FieldOrderType"] = "fieldOrderType"; + // DPI_FilterIconType, having type FilterIconType + ParameterId["FilterIconType"] = "filterIconType"; + // DPI_FilterIconTypes, having type FilterIconType[] + ParameterId["FilterIconTypes"] = "filterIconTypes"; + // DPI_FloatingToolbarVis, having type FloatingToolbarVisibility + ParameterId["FloatingToolbarVis"] = "toolbarVisibility"; + // DPI_FolderRole, having type FolderRole + ParameterId["FolderRole"] = "folderRole"; + // DPI_LegendType, having type Enum + ParameterId["LegendType"] = "legendType"; + // DPI_ForecastModelType, having type ForecastModelType + ParameterId["ForecastModelType"] = "forecastModelType"; + // DPI_ForecastTrendType, having type ForecastComponentType + ParameterId["ForecastTrendType"] = "forecastTrendType"; + // DPI_ForecastSeasonType, having type ForecastComponentType + ParameterId["ForecastSeasonType"] = "forecastSeasonType"; + // DPI_ForecastRangeType, having type ForecastRangeType + ParameterId["ForecastRangeType"] = "forecastRangeType"; + // DPI_ForecastStatus, having type ForecastStatus + ParameterId["ForecastStatus"] = "forecastStatus"; + // DPI_SheetForecastStatus, having type ForecastStatus + ParameterId["SheetForecastStatus"] = "sheetForecastStatus"; + // DPI_PDForecastStatusList, having type ForecastStatus[] + ParameterId["PDForecastStatusList"] = "paneDescriptorForecastStatusList"; + // DPI_ForecastColumnType, having type ForecastColumnType + ParameterId["ForecastColumnType"] = "forecastColumnType"; + // DPI_DataScaling, having type DataScaling + ParameterId["DataScaling"] = "dataScaling"; + // DPI_GetFilterItemsJsonResponse, having type GetJsonResponseEnum + ParameterId["GetFilterItemsJsonResponse"] = "getFilterItemsJsonResponse"; + // DPI_FilterSearchJsonResponse, having type GetJsonResponseEnum + ParameterId["FilterSearchJsonResponse"] = "filterSearchJsonResponse"; + // DPI_FilterSearchWithIndexJsonResponse, having type GetJsonResponseEnum + ParameterId["FilterSearchWithIndexJsonResponse"] = "filterSearchWithIndexJsonResponse"; + // DPI_FilterShowChildrenJsonResponse, having type GetJsonResponseEnum + ParameterId["FilterShowChildrenJsonResponse"] = "filterShowChildrenJsonResponse"; + // DPI_HAlignment, having type LabelHAlignment + ParameterId["HAlignment"] = "horizontalLabelAlignment"; + // DPI_JoinValidationError, having type JoinValidationError + ParameterId["JoinValidationError"] = "joinValidationError"; + // DPI_NameConflictResolution, having type NameConflictResolution + ParameterId["NameConflictResolution"] = "nameConflictResolution"; + // DPI_LabelDir, having type TextOrient + ParameterId["LabelDir"] = "labelDirection"; + // DPI_LabelAlign, having type TextAlign + ParameterId["LabelAlign"] = "labelAlignment"; + // DPI_LabelWrap, having type TextWrapMode + ParameterId["LabelWrap"] = "labelWrap"; + // DPI_WrapMode, having type TextWrapMode + ParameterId["WrapMode"] = "wrapMode"; + // DPI_MarkEnum, having type MarkEnum + ParameterId["MarkEnum"] = "markEnum"; + // DPI_PercentMode, having type PercentMode + ParameterId["PercentMode"] = "percentageMode"; + // DPI_ReferenceOptionsSet, having type ReferenceOptionsSet + ParameterId["ReferenceOptionsSet"] = "referenceOptionsSet"; + // DPI_ReferenceOptionsSets, having type ReferenceOptionsSet[] + ParameterId["ReferenceOptionsSets"] = "referenceOptionsSets"; + // DPI_RankType, having type RankType + ParameterId["RankType"] = "rankType"; + // DPI_RankTypeValues, having type RankType[] + ParameterId["RankTypeValues"] = "rankTypeValues"; + // DPI_SpecialValuesMode, having type SpecialValuesMode + ParameterId["SpecialValuesMode"] = "specialValuesMode"; + // DPI_VAlignment, having type LabelVAlignment + ParameterId["VAlignment"] = "verticalLabelAlignment"; + // DPI_ColorMode, having type ColorMode + ParameterId["ColorMode"] = "colorMode"; + // DPI_MarkLabelsMode, having type MarkLabelsMode + ParameterId["MarkLabelsMode"] = "markLabelsMode"; + // DPI_MarkLabelsScope, having type MarkLabelsScope + ParameterId["MarkLabelsScope"] = "markLabelsScope"; + // DPI_MarkLabelsVisibility, having type MarkLabelsVisibility + ParameterId["MarkLabelsVisibility"] = "markLabelsVisibility"; + // DPI_PrimitiveType, having type PrimitiveType + ParameterId["PrimitiveType"] = "primitiveType"; + // DPI_ActualPrimitiveType, having type PrimitiveType + ParameterId["ActualPrimitiveType"] = "actualPrimitiveType"; + // DPI_PrimitiveTypes, having type PrimitiveType[] + ParameterId["PrimitiveTypes"] = "primitiveTypes"; + // DPI_ShapeType, having type ShapeType + ParameterId["ShapeType"] = "shapeType"; + // DPI_SortType, having type SortType + ParameterId["SortType"] = "sortBy"; + // DPI_SortEnd, having type SortEnd + ParameterId["SortEnd"] = "sortEnd"; + // DPI_StackingMode, having type StackingMode + ParameterId["StackingMode"] = "stackingMode"; + // DPI_StyleTheme, having type StyleTheme + ParameterId["StyleTheme"] = "styleTheme"; + // DPI_TrendLineFitType, having type TrendLineFitType + ParameterId["TrendLineFitType"] = "fitType"; + // DPI_UpdateScope, having type UpdateScope + ParameterId["UpdateScope"] = "updateScope"; + // DPI_ParameterCtrlDisplayMode, having type DisplayMode + ParameterId["ParameterCtrlDisplayMode"] = "paramDisplayMode"; + // DPI_ParameterCtrlDisplayFlag, having type ParameterCtrlDisplayFlag + ParameterId["ParameterCtrlDisplayFlag"] = "paramDisplayFlag"; + // DPI_Included, having type QuantitativeIncludedValues + ParameterId["Included"] = "included"; + // DPI_CommandsType, having type CommandsType + ParameterId["CommandsType"] = "commandsType"; + // DPI_ParameterDomainType, having type DomainType + ParameterId["ParameterDomainType"] = "parameterDomainType"; + // DPI_FilterDomainType, having type DomainType + ParameterId["FilterDomainType"] = "filterDomainType"; + // DPI_FilterDomains, having type DomainType[] + ParameterId["FilterDomains"] = "filterDomains"; + // DPI_CategoricalFilterType, having type CategoricalFilterType + ParameterId["CategoricalFilterType"] = "categoricalFilterType"; + // DPI_FilterPatternType, having type PatternType + ParameterId["FilterPatternType"] = "filterPatternType"; + // DPI_FilterConditionType, having type ConditionType + ParameterId["FilterConditionType"] = "filterConditionType"; + // DPI_FiltersPresetType, having type PresetType + ParameterId["FiltersPresetType"] = "filtersPresetType"; + // DPI_FiltersRangeType, having type RangeType + ParameterId["FiltersRangeType"] = "filtersRangeType"; + // DPI_DateRangeType, having type RelativeDateRangeType + ParameterId["DateRangeType"] = "dateRangeType"; + // DPI_PageFlag, having type PageNavFlags + ParameterId["PageFlag"] = "pageFlag"; + // DPI_MarksToTrail, having type MarksToTrail + ParameterId["MarksToTrail"] = "marksToTrail"; + // DPI_TrailType, having type TrailType + ParameterId["TrailType"] = "trailType"; + // DPI_ChangePageDirection, having type ChangePageType + ParameterId["ChangePageDirection"] = "changeTo"; + // DPI_AnimationControl, having type PageAnimationControl + ParameterId["AnimationControl"] = "animationControl"; + // DPI_LinePattern, having type LinePattern + ParameterId["LinePattern"] = "linePattern"; + // DPI_LineCap, having type LineCap + ParameterId["LineCap"] = "lineCap"; + // DPI_LineJoin, having type LineJoin + ParameterId["LineJoin"] = "lineJoin"; + // DPI_LineAlignment, having type LineAlignment + ParameterId["LineAlignment"] = "lineAlignment"; + // DPI_FillMode, having type FillMode + ParameterId["FillMode"] = "fillMode"; + // DPI_CursorShape, having type CursorShape + ParameterId["CursorShape"] = "cursorShape"; + // DPI_ShowMeCommandType, having type ShowMeCommandType + ParameterId["ShowMeCommandType"] = "showMeCommandType"; + // DPI_ShelfIconType, having type ShelfIconType + ParameterId["ShelfIconType"] = "shelfIconType"; + // DPI_ShelfIconTypes, having type ShelfIconType[] + ParameterId["ShelfIconTypes"] = "shelfIconTypes"; + // DPI_ItemDrawStyle, having type ItemDrawStyle + ParameterId["ItemDrawStyle"] = "itemDrawStyle"; + // DPI_ScaleMode, having type ScaleMode + ParameterId["ScaleMode"] = "pageScaleMode"; + // DPI_PageOrientationOption, having type PageOrientation + ParameterId["PageOrientationOption"] = "pageOrientationOption"; + // DPI_PageSizeOption, having type PageSizeOption + ParameterId["PageSizeOption"] = "pageSizeOption"; + // DPI_SortRegionType, having type SortRegionType + ParameterId["SortRegionType"] = "sortRegion"; + // DPI_LegendItemLayout, having type LegendItemLayout + ParameterId["LegendItemLayout"] = "legendLayout"; + // DPI_LegendItemOrder, having type LegendItemOrder + ParameterId["LegendItemOrder"] = "legendOrder"; + // DPI_VizImageRegion, having type VizImageRegion + ParameterId["VizImageRegion"] = "r"; + // DPI_LegacyMenuName, having type LegacyMenuName + ParameterId["LegacyMenuName"] = "legacyMenuName"; + // DPI_LegacyMenuState, having type LegacyMenuState + ParameterId["LegacyMenuState"] = "legacyMenuState"; + // DPI_LegacyMenuStateList, having type LegacyMenuState[] + ParameterId["LegacyMenuStateList"] = "legacyMenuStates"; + // DPI_DimensionType, having type DimensionType + ParameterId["DimensionType"] = "dimensionType"; + // DPI_LayoutType, having type LayoutType + ParameterId["LayoutType"] = "layoutType"; + // DPI_ShelfType, having type ShelfType + ParameterId["ShelfType"] = "shelfType"; + // DPI_LastSelectionShelf, having type ShelfType + ParameterId["LastSelectionShelf"] = "lastShelf"; + // DPI_SchemaViewerDataSourceType, having type SchemaViewerDataSourceType + ParameterId["SchemaViewerDataSourceType"] = "schemaDatasourceType"; + // DPI_SchemaItemType, having type SchemaItemType + ParameterId["SchemaItemType"] = "schemaItemType"; + // DPI_HSMSelectionMode, having type SelectionMode + ParameterId["HSMSelectionMode"] = "hsmSelectionMode"; + // DPI_HSMDefaultMemberType, having type DefaultMemberType + ParameterId["HSMDefaultMemberType"] = "hsmDefaultMemberType"; + // DPI_HSMNotificationType, having type NotificationType + ParameterId["HSMNotificationType"] = "hsmNotificationType"; + // DPI_HSMSelectionRequestType, having type SelectionRequestType + ParameterId["HSMSelectionRequestType"] = "hsmSelectionRequestType"; + // DPI_HSMMemberSelectRequestType, having type MemberSelectRequestType + ParameterId["HSMMemberSelectRequestType"] = "hsmMemberSelectRequestType"; + // DPI_PivotStrategy, having type FieldPivotStrategy + ParameterId["PivotStrategy"] = "pivotStrategy"; + // DPI_AliasType, having type AliasType + ParameterId["AliasType"] = "aliasType"; + // DPI_DSODimensionSortOrder, having type DataSourceOrder + ParameterId["DSODimensionSortOrder"] = "dsoDimensionSortOrder"; + // DPI_DSOMeasureSortOrder, having type DataSourceOrder + ParameterId["DSOMeasureSortOrder"] = "dsoMeasureSortOrder"; + // DPI_DSOSortOrder, having type DataSourceOrder + ParameterId["DSOSortOrder"] = "dsoSortOrder"; + // DPI_VTAggType, having type VTAggType + ParameterId["VTAggType"] = "vtAggregation"; + // DPI_FieldTypeIconSet, having type FieldTypeIconSet + ParameterId["FieldTypeIconSet"] = "fieldIconSet"; + // DPI_VisualPart, having type VisualPart + ParameterId["VisualPart"] = "visualPart"; + // DPI_DefaultMapToolEnum, having type MapToolSelection + ParameterId["DefaultMapToolEnum"] = "defaultMapToolEnum"; + // DPI_DefaultMapUnitEnum, having type MapUnitSelectionEnum + ParameterId["DefaultMapUnitEnum"] = "defaultMapUnitEnum"; + // DPI_SceneModelDetail, having type Detail + ParameterId["SceneModelDetail"] = "sceneModelDetailEnum"; + // DPI_SceneModelHitType, having type HitType + ParameterId["SceneModelHitType"] = "sceneModelHitType"; + // DPI_HitTestStyle, having type HitTestStyle + ParameterId["HitTestStyle"] = "hitTestStyle"; + // DPI_MarkState, having type MarkState + ParameterId["MarkState"] = "markState"; + // DPI_SheetType, having type SheetType + ParameterId["SheetType"] = "sheetType"; + // DPI_DragSource, having type DragDropType + ParameterId["DragSource"] = "dragSource"; + // DPI_DropTarget, having type DragDropType + ParameterId["DropTarget"] = "dropTarget"; + // DPI_ShelfDropAction, having type ShelfDropAction + ParameterId["ShelfDropAction"] = "shelfDropAction"; + // DPI_ShelfDropContext, having type ShelfDropContext + ParameterId["ShelfDropContext"] = "shelfDropContext"; + // DPI_FilterSelectionTracking, having type SelectionTracking + ParameterId["FilterSelectionTracking"] = "filterSelectionTracking"; + // DPI_FilterUpdateType, having type FilterUpdateType + ParameterId["FilterUpdateType"] = "filterUpdateType"; + // DPI_FilterUpdateQualifierType, having type FilterUpdateQualifierType + ParameterId["FilterUpdateQualifierType"] = "filterUpdateQualifierType"; + // DPI_ParameterError, having type ParameterError + ParameterId["ParameterError"] = "parameterError"; + // DPI_SelectionType, having type SelectionType + ParameterId["SelectionType"] = "selectionType"; + // DPI_SelectionUpdateType, having type SelectionUpdateType + ParameterId["SelectionUpdateType"] = "selectionUpdateType"; + // DPI_SelectOptions, having type SelectOptions + ParameterId["SelectOptions"] = "selectOptions"; + // DPI_WhitespaceSelectionBehavior, having type WhitespaceSelectionBehavior + ParameterId["WhitespaceSelectionBehavior"] = "whitespaceSelectionBehavior"; + // DPI_AxisOrientation, having type Orientation + ParameterId["AxisOrientation"] = "axisOrientation"; + // DPI_DecimalMode, having type DecimalMode + ParameterId["DecimalMode"] = "decimalMode"; + // DPI_ActivationMethod, having type ActivationMethod + ParameterId["ActivationMethod"] = "activation"; + // DPI_SourceType, having type SourceType + ParameterId["SourceType"] = "sourceType"; + // DPI_OnClear, having type OnClear + ParameterId["OnClear"] = "onClear"; + // DPI_MergeOrSplit, having type MergeOrSplit + ParameterId["MergeOrSplit"] = "mergeOrSplit"; + // DPI_FilterMode, having type FilterMode + ParameterId["FilterMode"] = "filterMode"; + // DPI_FilterType, having type FilterType + ParameterId["FilterType"] = "filterType"; + // DPI_ZoneType, having type ZoneType + ParameterId["ZoneType"] = "zoneType"; + // DPI_ZoneLayoutType, having type ZoneLayoutType + ParameterId["ZoneLayoutType"] = "zoneLayoutType"; + // DPI_QuickTableCalcType, having type QuickTableCalcCommandType + ParameterId["QuickTableCalcType"] = "quickTableCalcType"; + // DPI_TableCalcCommandType, having type TableCalcCommandType + ParameterId["TableCalcCommandType"] = "tableCalcCommandType"; + // DPI_TableCalcAddressType, having type TableCalcAddressCommandType + ParameterId["TableCalcAddressType"] = "tableCalcAddressType"; + // DPI_MarkLayoutPrimitive, having type Primitive + ParameterId["MarkLayoutPrimitive"] = "markLayoutPrimitive"; + // DPI_MarkLayoutVizType, having type VizType + ParameterId["MarkLayoutVizType"] = "markLayoutVizType"; + // DPI_MarkAlignment, having type MarkAlignment + ParameterId["MarkAlignment"] = "markAlignment"; + // DPI_ModifyZoneZOrderType, having type ModifyZoneZOrderCommandType + ParameterId["ModifyZoneZOrderType"] = "modifyZoneZOrderType"; + // DPI_TextRegionHAlign, having type TextRegionHAlign + ParameterId["TextRegionHAlign"] = "halign"; + // DPI_TextRegionVAlign, having type TextRegionVAlign + ParameterId["TextRegionVAlign"] = "valign"; + // DPI_PathElement, having type PathElement + ParameterId["PathElement"] = "pathElement"; + // DPI_PathElements, having type PathElement[] + ParameterId["PathElements"] = "pathElements"; + // DPI_RenderMode, having type RenderMode + ParameterId["RenderMode"] = "renderMode"; + // DPI_FontStyle, having type TableauFontStyle + ParameterId["FontStyle"] = "fontStyle"; + // DPI_FontWeight, having type FontWeight + ParameterId["FontWeight"] = "fontWeight"; + // DPI_TextDecoration, having type TextDecoration + ParameterId["TextDecoration"] = "textDecoration"; + // DPI_BorderStyle, having type BorderStyle + ParameterId["BorderStyle"] = "borderStyle"; + // DPI_BorderStyleTop, having type BorderStyle + ParameterId["BorderStyleTop"] = "borderStyleTop"; + // DPI_BorderStyleRight, having type BorderStyle + ParameterId["BorderStyleRight"] = "borderStyleRight"; + // DPI_BorderStyleBottom, having type BorderStyle + ParameterId["BorderStyleBottom"] = "borderStyleBottom"; + // DPI_BorderStyleLeft, having type BorderStyle + ParameterId["BorderStyleLeft"] = "borderStyleLeft"; + // DPI_FloatingToolbarVisibility, having type FloatingToolbarVisibility + ParameterId["FloatingToolbarVisibility"] = "floatingToolbarVisibility"; + // DPI_GeoSearchVisibility, having type GeoSearchVisibility + ParameterId["GeoSearchVisibility"] = "geographicSearchVisibility"; + // DPI_MapScaleVisibility, having type MapScaleVisibility + ParameterId["MapScaleVisibility"] = "mapScaleVisibility"; + // DPI_VizNavigationSetting, having type VizNavigationSetting + ParameterId["VizNavigationSetting"] = "vizNavigationSetting"; + // DPI_AutoDrillVisibility, having type AutoDrillVisibility + ParameterId["AutoDrillVisibility"] = "autoDrillVisibility"; + // DPI_ClientUIMetricType, having type ClientUIMetricType + ParameterId["ClientUIMetricType"] = "clientUiMetricType"; + // DPI_SheetScrollDirection, having type SheetScrollDirection + ParameterId["SheetScrollDirection"] = "sheetScrollDirection"; + // DPI_SizeMode, having type SizeMode + ParameterId["SizeMode"] = "sizeMode"; + // DPI_PerspectiveAggregate, having type PerspectiveAggregate + ParameterId["PerspectiveAggregate"] = "perspectiveAggregation"; + // DPI_StyleAttribute, having type StyleAttribute + ParameterId["StyleAttribute"] = "styleAttribute"; + // DPI_StyleAttributes, having type StyleAttribute[] + ParameterId["StyleAttributes"] = "styleAttributes"; + // DPI_StyleElement, having type StyleElement + ParameterId["StyleElement"] = "styleElement"; + // DPI_StyleDataClass, having type StyleDataClass + ParameterId["StyleDataClass"] = "styleClass"; + // DPI_StyleFieldScope, having type StyleFieldScope + ParameterId["StyleFieldScope"] = "styleScope"; + // DPI_FormatControlType, having type FormatControlType + ParameterId["FormatControlType"] = "formatType"; + // DPI_LineInterpolationMode, having type LineInterpolationMode + ParameterId["LineInterpolationMode"] = "lineInterpolationMode"; + // DPI_LineMarkerPosition, having type LineMarkerPosition + ParameterId["LineMarkerPosition"] = "lineMarkerPosition"; + // DPI_MarkersMode, having type MarkMarkersMode + ParameterId["MarkersMode"] = "markersMode"; + // DPI_AppConfigEnum, having type AppConfigEnum + ParameterId["AppConfigEnum"] = "appConfigEnum"; + // DPI_ColorPaletteType, having type ColorPaletteType + ParameterId["ColorPaletteType"] = "colorPaletteType"; + // DPI_ExtractType, having type ExtractType + ParameterId["ExtractType"] = "extractType"; + // DPI_ActivityDisposition, having type ActivityDisposition + ParameterId["ActivityDisposition"] = "activityDisposition"; + // DPI_ActivityResult, having type ActivityResult + ParameterId["ActivityResult"] = "activityResult"; + // DPI_TooltipMode, having type TooltipMode + ParameterId["TooltipMode"] = "tooltipMode"; + // DPI_RuntimeOutput, having type RuntimeOutput + ParameterId["RuntimeOutput"] = "runtimeOutput"; + // DPI_AnalyticsObjectType, having type AnalyticsObjectType + ParameterId["AnalyticsObjectType"] = "analyticsObjectType"; + // DPI_UIAutomationStatus, having type UIAutomationCommandStatus + ParameterId["UIAutomationStatus"] = "uiAutomationStatus"; + // DPI_TableViewDataType, having type TableViewDataType + ParameterId["TableViewDataType"] = "tableViewerDataType"; + // DPI_UnitsFormat, having type UnitsFormatEnum + ParameterId["UnitsFormat"] = "unitsFormat"; + // DPI_FilterLimitType, having type LimitType + ParameterId["FilterLimitType"] = "filterLimitType"; + // DPI_DistributionSelectedType, having type DistributionType + ParameterId["DistributionSelectedType"] = "distributionSelectedType"; + // DPI_DistributionType, having type DistributionType + ParameterId["DistributionType"] = "distributionType"; + // DPI_TranslatedDistributionType, having type TranslatedDistributionTypePresModel + ParameterId["TranslatedDistributionType"] = "translatedDistributionType"; + // DPI_TranslatedDistributionTypes, having type TranslatedDistributionTypePresModel[] + ParameterId["TranslatedDistributionTypes"] = "translatedDistributionTypes"; + // DPI_RefLineFormulaGroup, having type FormulaGroup + ParameterId["RefLineFormulaGroup"] = "reflineFormulaGroup"; + // DPI_ReferenceLineScopeType, having type ScopeType + ParameterId["ReferenceLineScopeType"] = "referenceLineScopeType"; + // DPI_StDevType, having type StDevType + ParameterId["StDevType"] = "stdevType"; + // DPI_ShowBounds, having type ShowBounds + ParameterId["ShowBounds"] = "showBounds"; + // DPI_BoxplotWhiskerType, having type BoxplotWhiskerType + ParameterId["BoxplotWhiskerType"] = "boxplotWhiskerType"; + // DPI_ReferenceLineLabelType, having type LabelType + ParameterId["ReferenceLineLabelType"] = "referenceLineLabelType"; + // DPI_PairedReferenceLineLabelType, having type LabelType + ParameterId["PairedReferenceLineLabelType"] = "pairedReferenceLineLabelType"; + // DPI_ConfidenceIntervalSelectedState, having type ConfidenceIntervalState + ParameterId["ConfidenceIntervalSelectedState"] = "confidenceIntervalSelectedState"; + // DPI_ConfidenceIntervalState, having type ConfidenceIntervalState + ParameterId["ConfidenceIntervalState"] = "confidenceIntervalState"; + // DPI_TranslatedLabelType, having type TranslatedLabelTypePresModel + ParameterId["TranslatedLabelType"] = "translatedLabelType"; + // DPI_ReferenceLineValidLabelTypes, having type TranslatedLabelTypePresModel[] + ParameterId["ReferenceLineValidLabelTypes"] = "validReferenceLineLabelTypes"; + // DPI_ReferenceLineFormulaType, having type FormulaType + ParameterId["ReferenceLineFormulaType"] = "referenceLineFormulaType"; + // DPI_PairedReferenceLineFormulaType, having type FormulaType + ParameterId["PairedReferenceLineFormulaType"] = "pairedReferenceLineFormulaType"; + // DPI_TranslatedFormulaType, having type TranslatedFormulaTypePresModel + ParameterId["TranslatedFormulaType"] = "translatedFormulaType"; + // DPI_ReferenceLineValidFormulaTypes, having type TranslatedFormulaTypePresModel[] + ParameterId["ReferenceLineValidFormulaTypes"] = "validReferenceLineFormulaTypes"; + // DPI_ReferenceLineValidPairedFormulaTypes, having type TranslatedFormulaTypePresModel[] + ParameterId["ReferenceLineValidPairedFormulaTypes"] = "validReferenceLinePairedFormulaTypes"; + // DPI_TranslatedConfidenceIntervalState, having type TranslatedConfidenceIntervalStatePresModel + ParameterId["TranslatedConfidenceIntervalState"] = "translatedConfidenceIntervalState"; + // DPI_TranslatedConfidenceIntervalStates, having type TranslatedConfidenceIntervalStatePresModel[] + ParameterId["TranslatedConfidenceIntervalStates"] = "translatedConfidenceIntervalStates"; + // DPI_TranslatedStDevType, having type TranslatedStDevTypePresModel + ParameterId["TranslatedStDevType"] = "translatedStdevType"; + // DPI_TranslatedStDevTypes, having type TranslatedStDevTypePresModel[] + ParameterId["TranslatedStDevTypes"] = "translatedStdevTypes"; + // DPI_ReferenceLineLODCalcType, having type LODCalcType + ParameterId["ReferenceLineLODCalcType"] = "referenceLineLodCalcType"; + // DPI_ValueDomainType, having type ValueDomainType + ParameterId["ValueDomainType"] = "valueDomainType"; + // DPI_ValueDomainTypes, having type ValueDomainType[] + ParameterId["ValueDomainTypes"] = "valueDomainTypes"; + // DPI_OperationType, having type OperationType + ParameterId["OperationType"] = "operationType"; + // DPI_OperationTypes, having type OperationType[] + ParameterId["OperationTypes"] = "operationTypes"; + // DPI_ConnectionTypeCategory, having type ConnectionTypeCategory + ParameterId["ConnectionTypeCategory"] = "connectionTypeCategory"; + // DPI_ConnectionTypeGroup, having type ConnectionTypeGroup + ParameterId["ConnectionTypeGroup"] = "connectionTypeGroup"; + // DPI_CommandRedirectType, having type CommandRedirectType + ParameterId["CommandRedirectType"] = "commandRedirectType"; + // DPI_CustomSplitMode, having type SplitMode + ParameterId["CustomSplitMode"] = "customSplitMode"; + // DPI_CustomSplitSeparatorType, having type SeparatorType + ParameterId["CustomSplitSeparatorType"] = "customSplitSeparatorType"; + // DPI_LevelSelectionState, having type LevelSelectionState + ParameterId["LevelSelectionState"] = "levelSelectionState"; + // DPI_LevelSelectionStates, having type LevelSelectionState[] + ParameterId["LevelSelectionStates"] = "levelSelectionStates"; + // DPI_SourceDestIcon, having type SourceDestIcon + ParameterId["SourceDestIcon"] = "sourceDestIcon"; + // DPI_LegendLayout, having type LegendLayout + ParameterId["LegendLayout"] = "pageLegendLayout"; + // DPI_ImagesEditResultCode, having type ImagesEditResultCode + ParameterId["ImagesEditResultCode"] = "imagesEditResultCode"; + // DPI_CalculationContext, having type CalculationContext + ParameterId["CalculationContext"] = "calculationContext"; + // DPI_WorkgroupPublishErrorType, having type WorkgroupPublishErrorType + ParameterId["WorkgroupPublishErrorType"] = "workgroupPublishErrorType"; + // DPI_IsParameter, having type TriBool + ParameterId["IsParameter"] = "isParameter"; + // DPI_AddressingState, having type WidgetState + ParameterId["AddressingState"] = "addressingState"; + // DPI_AllPagesState, having type WidgetState + ParameterId["AllPagesState"] = "allPagesState"; + // DPI_AtTheLevelState, having type WidgetState + ParameterId["AtTheLevelState"] = "atTheLevelState"; + // DPI_ComputeCompoundedRateState, having type WidgetState + ParameterId["ComputeCompoundedRateState"] = "computeCompoundedRateState"; + // DPI_CustomNullIfIncompleteState, having type WidgetState + ParameterId["CustomNullIfIncompleteState"] = "customNullIfIncompleteState"; + // DPI_NestedCalcsState, having type WidgetState + ParameterId["NestedCalcsState"] = "nestedCalcsState"; + // DPI_RankTypeState, having type WidgetState + ParameterId["RankTypeState"] = "rankTypeState"; + // DPI_ReferenceOptionsState, having type WidgetState + ParameterId["ReferenceOptionsState"] = "referenceOptionsState"; + // DPI_RestartEveryState, having type WidgetState + ParameterId["RestartEveryState"] = "restartEveryState"; + // DPI_SortAggState, having type WidgetState + ParameterId["SortAggState"] = "sortAggState"; + // DPI_SortState, having type WidgetState + ParameterId["SortState"] = "sortState"; + // DPI_TableCalcTypeState, having type WidgetState + ParameterId["TableCalcTypeState"] = "tableCalcTypeState"; + // DPI_TableCalcAssistanceWidgetState, having type WidgetState + ParameterId["TableCalcAssistanceWidgetState"] = "tableCalcAssistanceWidgetState"; + // DPI_CalcNestingLevel, having type CalcNestingLevel + ParameterId["CalcNestingLevel"] = "calcNestingLevel"; + // DPI_DataProviderType, having type DataProviderType + ParameterId["DataProviderType"] = "dataProviderType"; + // DPI_HeuristicCommandReinterpretation, having type HeuristicCommandReinterpretation + ParameterId["HeuristicCommandReinterpretation"] = "heuristicCommandReinterpretation"; + // DPI_ExtractRefreshStatus, having type ExtractRefreshStatus + ParameterId["ExtractRefreshStatus"] = "extractRefreshStatus"; + // DPI_RichTextEditorWidgetKey, having type RichTextEditorWidgetKey + ParameterId["RichTextEditorWidgetKey"] = "richTextEditorWidgetKey"; + // DPI_RichTextWidgetKeys, having type RichTextEditorWidgetKey[] + ParameterId["RichTextWidgetKeys"] = "richTextWidgetKeys"; + // DPI_TypeOfFormatItem, having type TypeOfFormatItem + ParameterId["TypeOfFormatItem"] = "typeOfFormatItem"; + // DPI_TypeOfFormatContainer, having type TypeOfFormatContainer + ParameterId["TypeOfFormatContainer"] = "typeOfFormatContainer"; + // DPI_TypeOfFormatControl, having type TypeOfFormatControl + ParameterId["TypeOfFormatControl"] = "typeOfFormatControl"; + // DPI_FormatWidgetKey, having type FormatWidgetKey + ParameterId["FormatWidgetKey"] = "formatWidgetKey"; + // DPI_ColorSwatchType, having type ColorSwatchType + ParameterId["ColorSwatchType"] = "formatColorSwatchType"; + // DPI_PickerType, having type PickerType + ParameterId["PickerType"] = "pickerType"; + // DPI_ExtractHistoryRefreshType, having type RefreshType + ParameterId["ExtractHistoryRefreshType"] = "extractHistoryRefreshTypeEnum"; + // DPI_AxisFoldState, having type AxisFoldState + ParameterId["AxisFoldState"] = "axisFoldState"; + // DPI_TickMarkSpacingUnits, having type TickSpacingUnits + ParameterId["TickMarkSpacingUnits"] = "tickSpacingUnits"; + // DPI_TickMarkState, having type TickMarkState + ParameterId["TickMarkState"] = "tickMarkState"; + // DPI_AxisRangeType, having type AxisRangeType + ParameterId["AxisRangeType"] = "axisRangeType"; + // DPI_ScaleType, having type ScaleType + ParameterId["ScaleType"] = "scaleType"; + // DPI_DashboardDeviceLayout, having type DashboardDeviceLayout + ParameterId["DashboardDeviceLayout"] = "dashboardDeviceLayout"; + // DPI_ActivateDeviceLayout, having type DashboardDeviceLayout + ParameterId["ActivateDeviceLayout"] = "activateDeviceLayout"; + // DPI_DashboardDeviceLayouts, having type DashboardDeviceLayout[] + ParameterId["DashboardDeviceLayouts"] = "dashboardDeviceLayouts"; + // DPI_DeviceSource, having type DeviceSource + ParameterId["DeviceSource"] = "deviceSource"; + // DPI_DashboardSizingDimension, having type DashboardSizingDimension + ParameterId["DashboardSizingDimension"] = "dashboardSizingDimension"; + // DPI_GridOverlayMode, having type GridOverlayMode + ParameterId["GridOverlayMode"] = "gridOverlayMode"; + // DPI_DashboardSizingMode, having type DashboardSizingMode + ParameterId["DashboardSizingMode"] = "dashboardSizingMode"; + // DPI_FlipboardNavType, having type FlipboardNavType + ParameterId["FlipboardNavType"] = "flipboardNavType"; + // DPI_FieldPickerDialogUseCase, having type FieldPickerDialogUseCase + ParameterId["FieldPickerDialogUseCase"] = "fieldPickerDialogUseCase"; + // DPI_StartOfWeekEnum, having type SOWValue + ParameterId["StartOfWeekEnum"] = "startOfWeekEnum"; + // DPI_StartOfFiscalYear, having type FYSValues + ParameterId["StartOfFiscalYear"] = "startOfFiscalYear"; + // DPI_TotalsInclusionValue, having type TotalsInclusion + ParameterId["TotalsInclusionValue"] = "totalsInclusionValue"; + // DPI_FormatCode, having type FormatCode + ParameterId["FormatCode"] = "formatCode"; + // DPI_FindType, having type FindType + ParameterId["FindType"] = "findType"; + // DPI_PerspectiveType, having type PerspectiveType + ParameterId["PerspectiveType"] = "perspectiveType"; + // DPI_GeometryType, having type GeometryType + ParameterId["GeometryType"] = "geometryType"; + // DPI_PaneLabelComposition, having type PaneLabelComposition + ParameterId["PaneLabelComposition"] = "paneLabelComposition"; + // DPI_WarningType, having type WarningType + ParameterId["WarningType"] = "warningType"; + // DPI_UIMode, having type WorkbookUIMode + ParameterId["UIMode"] = "uiMode"; + // DPI_MenuItemId, having type TopLevelMenuItem + ParameterId["MenuItemId"] = "menuItemId"; + // DPI_CommandReturn, having type object + ParameterId["CommandReturn"] = "commandReturn"; + // DPI_LegacyPresModel, having type object + ParameterId["LegacyPresModel"] = "legacyPresModel"; + // DPI_PresentationModel, having type object + ParameterId["PresentationModel"] = "presModelHolder"; + // DPI_Event, having type object + ParameterId["Event"] = "eventContainer"; + // DPI_LineStyle, having type Array + ParameterId["LineStyle"] = "lineStyle"; + // DPI_StrokeStyle, having type Array + ParameterId["StrokeStyle"] = "strokeStyle"; + // DPI_Schema, having type Array + ParameterId["Schema"] = "schema"; + // DPI_StartTuple, having type Array + ParameterId["StartTuple"] = "startTuple"; + // DPI_EndTuple, having type Array + ParameterId["EndTuple"] = "endTuple"; + // DPI_Tuple, having type Array + ParameterId["Tuple"] = "tuple"; + // DPI_Tuples, having type Array[] + ParameterId["Tuples"] = "tuples"; + // DPI_CustomDomainTuples, having type Array[] + ParameterId["CustomDomainTuples"] = "customDomainTuples"; + // DPI_UpdatedTuples, having type Array[] + ParameterId["UpdatedTuples"] = "updatedTuples"; + // DPI_Table, having type Array + ParameterId["Table"] = "table"; + // DPI_AliasedValue, having type Array + ParameterId["AliasedValue"] = "valueAlias"; + // DPI_FirstAliasedValue, having type Array + ParameterId["FirstAliasedValue"] = "firstAlisedValue"; + // DPI_MaximumRange, having type Array + ParameterId["MaximumRange"] = "maximumRangeValue"; + // DPI_MinimumRange, having type Array + ParameterId["MinimumRange"] = "minimumRangeValue"; + // DPI_SecondAliasedValue, having type Array + ParameterId["SecondAliasedValue"] = "secondAlisedValue"; + // DPI_AliasedSelectionList, having type Array[] + ParameterId["AliasedSelectionList"] = "aliasedSelectionList"; + // DPI_AliasedValues, having type Array[] + ParameterId["AliasedValues"] = "valuesAliases"; + // DPI_VerboseAliasedRangeMax, having type Array + ParameterId["VerboseAliasedRangeMax"] = "verboseAliasedRangeMax"; + // DPI_VerboseAliasedValue, having type Array + ParameterId["VerboseAliasedValue"] = "verboseAliasedValue"; + // DPI_MultiBucket, having type MultiBucket + ParameterId["MultiBucket"] = "xValues"; + // DPI_PageName, having type PageName + ParameterId["PageName"] = "pageName"; + // DPI_Selector, having type object + ParameterId["Selector"] = "selector"; + // DPI_PaneId, having type object + ParameterId["PaneId"] = "paneId"; + // DPI_PaneIds, having type PaneId[] + ParameterId["PaneIds"] = "paneIds"; + // DPI_ImageRegionInfo, having type object + ParameterId["ImageRegionInfo"] = "vizRegionRect"; + // DPI_ImageRegionInfoList, having type object[] + ParameterId["ImageRegionInfoList"] = "vizRegionRectList"; + // DPI_VisualID, having type VisualID + ParameterId["VisualID"] = "visualId"; + // DPI_VisualIDPM, having type VisualIDPresModel + ParameterId["VisualIDPM"] = "visualIdPresModel"; + // DPI_InvalidSheets, having type VisualIDPresModel[] + ParameterId["InvalidSheets"] = "invalidSheets"; + // DPI_VisualIDPMs, having type VisualIDPresModel[] + ParameterId["VisualIDPMs"] = "visualIds"; + // DPI_SheetPathPM, having type SheetPathPresModel + ParameterId["SheetPathPM"] = "sheetPath"; + // DPI_CapturedSheetPM, having type SheetPathPresModel + ParameterId["CapturedSheetPM"] = "capturedSheetPm"; + // DPI_CurrentSheetPM, having type SheetPathPresModel + ParameterId["CurrentSheetPM"] = "currentSheetPm"; + // DPI_DashboardPM, having type SheetPathPresModel + ParameterId["DashboardPM"] = "dashboardPm"; + // DPI_NewSheetPM, having type SheetPathPresModel + ParameterId["NewSheetPM"] = "newSheetPm"; + // DPI_SheetNamePM, having type SheetPathPresModel + ParameterId["SheetNamePM"] = "sheetNamePm"; + // DPI_SheetPM, having type SheetPathPresModel + ParameterId["SheetPM"] = "sheetPm"; + // DPI_SourceDashboardPM, having type SheetPathPresModel + ParameterId["SourceDashboardPM"] = "sourceDashboardPm"; + // DPI_SourceSheetPM, having type SheetPathPresModel + ParameterId["SourceSheetPM"] = "sourceSheetPm"; + // DPI_TargetSheetPM, having type SheetPathPresModel + ParameterId["TargetSheetPM"] = "targetSheetPm"; + // DPI_WorksheetPM, having type SheetPathPresModel + ParameterId["WorksheetPM"] = "worksheetPm"; + // DPI_ModifiedSheets, having type SheetPathPresModel[] + ParameterId["ModifiedSheets"] = "modifiedSheets"; + // DPI_DataColumn, having type DataColumnPresModel + ParameterId["DataColumn"] = "dataColumn"; + // DPI_DataColumns, having type DataColumnPresModel[] + ParameterId["DataColumns"] = "dataColumns"; + // DPI_Addresses, having type DataColumnPresModel[] + ParameterId["Addresses"] = "addresses"; + // DPI_EncodingColumns, having type Dictionary(of DataColumnPresModel) + ParameterId["EncodingColumns"] = "encodingColumns"; + // DPI_TextRunColumns, having type Dictionary(of DataColumnPresModel) + ParameterId["TextRunColumns"] = "textRunColumns"; + // DPI_TextStyleColumns, having type Dictionary(of DataColumnPresModel) + ParameterId["TextStyleColumns"] = "textStyleColumns"; + // DPI_NamedDataColumn, having type NamedDataColumnPresModel + ParameterId["NamedDataColumn"] = "namedDataColumn"; + // DPI_NamedDataColumns, having type NamedDataColumnPresModel[] + ParameterId["NamedDataColumns"] = "namedDataColumns"; + // DPI_DataTable, having type DataTablePresModel + ParameterId["DataTable"] = "dataTable"; + // DPI_ActionSpecification, having type None + ParameterId["ActionSpecification"] = "actionSpec"; + // DPI_Column, having type Column + ParameterId["Column"] = "columnContext"; + // DPI_SetFunction, having type SetFunction + ParameterId["SetFunction"] = "setFunction"; + // DPI_SetFunctions, having type SetFunctions + ParameterId["SetFunctions"] = "setFunctions"; + // DPI_VisualProfileShowMe, having type VisualProfileShowMe + ParameterId["VisualProfileShowMe"] = "vpsm"; + // DPI_DataSourcePtr, having type DataSource + ParameterId["DataSourcePtr"] = "datasourcePtr"; + // DPI_WorkgroupConnection, having type WorkgroupConnection + ParameterId["WorkgroupConnection"] = "workgroupConnection"; + // DPI_Authenticator, having type AuthenticatorRawPtr + ParameterId["Authenticator"] = "authenticator"; + // DPI_UpgradeAttr, having type UpgradeAttr + ParameterId["UpgradeAttr"] = "upgradeAttr"; + // DPI_ExtractAttr, having type ExtractAttr + ParameterId["ExtractAttr"] = "extractAttr"; + // DPI_RefreshAttr, having type RefreshAttr + ParameterId["RefreshAttr"] = "refreshAttr"; + // DPI_ContextSpecification, having type ContextSpecification + ParameterId["ContextSpecification"] = "contextSpecification"; + // DPI_SchemaViewerSelector, having type SchemaViewerSelectorPtr + ParameterId["SchemaViewerSelector"] = "schemaViewerSelector"; + // DPI_Buckets, having type Buckets + ParameterId["Buckets"] = "buckets"; + // DPI_LegendItems, having type MultiBuckets + ParameterId["LegendItems"] = "legendItems"; + // DPI_LegendItem, having type MultiBucket + ParameterId["LegendItem"] = "legendItem"; + // DPI_SourceItem, having type MultiBucket + ParameterId["SourceItem"] = "sourceItem"; + // DPI_DestItem, having type MultiBucket + ParameterId["DestItem"] = "destItem"; + // DPI_IQuickSortState, having type IQuickSortState + ParameterId["IQuickSortState"] = "quickSortState"; + // DPI_AppBuildDate, having type DateTime + ParameterId["AppBuildDate"] = "appBuildDate"; + // DPI_ForecastDateRangeEnd, having type DateTime + ParameterId["ForecastDateRangeEnd"] = "forecastDateRangeEnd"; + // DPI_ForecastDateRangeStart, having type DateTime + ParameterId["ForecastDateRangeStart"] = "forecastDateRangeStart"; + // DPI_LastModified, having type DateTime + ParameterId["LastModified"] = "lastModified"; + // DPI_SearchDomainPtr, having type MultiDomain + ParameterId["SearchDomainPtr"] = "searchDomainPtr"; + // DPI_ResultsDomainPtr, having type MultiDomain + ParameterId["ResultsDomainPtr"] = "resultsDomainPtr"; + // DPI_Actions, having type object + ParameterId["Actions"] = "actions"; + // DPI_SRCommands, having type object + ParameterId["SRCommands"] = "selectionRelaxationCommands"; + // DPI_Commands, having type object + ParameterId["Commands"] = "commands"; + // DPI_DataTypeCommands, having type object + ParameterId["DataTypeCommands"] = "datatypeCommands"; + // DPI_MultiSelectCommands, having type object + ParameterId["MultiSelectCommands"] = "multiselectCommands"; + // DPI_NonVizCommands, having type object + ParameterId["NonVizCommands"] = "nonVizCommands"; + // DPI_QuickFilterCommands, having type object + ParameterId["QuickFilterCommands"] = "quickFilterCommands"; + // DPI_ShowMeCommands, having type object + ParameterId["ShowMeCommands"] = "showMeCommands"; + // DPI_SortIndicatorMenu, having type object + ParameterId["SortIndicatorMenu"] = "sortIndicatorMenu"; + // DPI_StandardCommands, having type object + ParameterId["StandardCommands"] = "standardCommands"; + // DPI_VizCommands, having type object + ParameterId["VizCommands"] = "vizCommands"; + // DPI_ZoneChromeCommands, having type object + ParameterId["ZoneChromeCommands"] = "zoneChromeCommands"; + // DPI_CommandItem, having type CommandsItem + ParameterId["CommandItem"] = "commandItem"; + // DPI_CommandItems, having type CommandsItem[] + ParameterId["CommandItems"] = "commandItems"; + // DPI_Command, having type SimpleCommandsPresModel + ParameterId["Command"] = "simpleCommandModel"; + // DPI_AddCommand, having type SimpleCommandsPresModel + ParameterId["AddCommand"] = "addSimpleCommandModel"; + // DPI_RemoveCommand, having type SimpleCommandsPresModel + ParameterId["RemoveCommand"] = "removeSimpleCommandModel"; + // DPI_AcceptCommand, having type SimpleCommandsPresModel + ParameterId["AcceptCommand"] = "acceptSimpleCommandModel"; + // DPI_DeclineCommand, having type SimpleCommandsPresModel + ParameterId["DeclineCommand"] = "declineSimpleCommandModel"; + // DPI_DropCommand, having type SimpleCommandsPresModel + ParameterId["DropCommand"] = "dropCommandModel"; + // DPI_EditCaptionCommand, having type SimpleCommandsPresModel + ParameterId["EditCaptionCommand"] = "editCaptionCommandModel"; + // DPI_FontCommand, having type SimpleCommandsPresModel + ParameterId["FontCommand"] = "fontCommandModel"; + // DPI_LineStyleCommand, having type SimpleCommandsPresModel + ParameterId["LineStyleCommand"] = "lineStyleCommandModel"; + // DPI_FormatCommand, having type SimpleCommandsPresModel + ParameterId["FormatCommand"] = "formatCommandModel"; + // DPI_DestructorCommand, having type SimpleCommandsPresModel + ParameterId["DestructorCommand"] = "destructorCommand"; + // DPI_ClearFormatCommand, having type SimpleCommandsPresModel + ParameterId["ClearFormatCommand"] = "clearFormatCommandModel"; + // DPI_RichTextCommand, having type SimpleCommandsPresModel + ParameterId["RichTextCommand"] = "richTextCommandModel"; + // DPI_SortIndicatorCommand, having type SimpleCommandsPresModel + ParameterId["SortIndicatorCommand"] = "sortIndicatorCommand"; + // DPI_ReleaseStoreCommand, having type SimpleCommandsPresModel + ParameterId["ReleaseStoreCommand"] = "releaseStoreCommand"; + // DPI_ConfirmationCommand, having type SimpleCommandsPresModel + ParameterId["ConfirmationCommand"] = "confirmationCommand"; + // DPI_CommandList, having type SimpleCommandsPresModel[] + ParameterId["CommandList"] = "commandList"; + // DPI_ParameterCtrl, having type ParameterCtrlPresModel + ParameterId["ParameterCtrl"] = "parameterControl"; + // DPI_ParameterCtrls, having type ParameterCtrlPresModel[] + ParameterId["ParameterCtrls"] = "parameterControls"; + // DPI_PageModel, having type PagePresModel + ParameterId["PageModel"] = "pageModel"; + // DPI_PageTrailOptions, having type PageTrailOptionsPresModel + ParameterId["PageTrailOptions"] = "pageTrailOptions"; + // DPI_Field, having type FieldPresModel + ParameterId["Field"] = "field"; + // DPI_FieldList, having type FieldPresModel[] + ParameterId["FieldList"] = "fieldList"; + // DPI_DimensionsFieldList, having type FieldPresModel[] + ParameterId["DimensionsFieldList"] = "dimensionsFieldList"; + // DPI_MeasuresFieldList, having type FieldPresModel[] + ParameterId["MeasuresFieldList"] = "measuresFieldList"; + // DPI_SetsFieldList, having type FieldPresModel[] + ParameterId["SetsFieldList"] = "setsFieldList"; + // DPI_ParametersFieldList, having type FieldPresModel[] + ParameterId["ParametersFieldList"] = "parametersFieldList"; + // DPI_FieldColumn, having type FieldColumnPresModel + ParameterId["FieldColumn"] = "column"; + // DPI_FieldColumnList, having type FieldColumnPresModel[] + ParameterId["FieldColumnList"] = "columnList"; + // DPI_StructuredMeasure, having type StructuredMeasurePresModel + ParameterId["StructuredMeasure"] = "structuredMeasure"; + // DPI_StructuredMeasureList, having type StructuredMeasurePresModel[] + ParameterId["StructuredMeasureList"] = "structuredMeasureList"; + // DPI_Level, having type LevelPresModel + ParameterId["Level"] = "level"; + // DPI_Parameter, having type ParameterPresModel + ParameterId["Parameter"] = "parameter"; + // DPI_BaseDimension, having type BaseDimensionPresModel + ParameterId["BaseDimension"] = "baseDimension"; + // DPI_Dimension, having type DimensionPresModel + ParameterId["Dimension"] = "dimension"; + // DPI_AttributeDimensionList, having type DimensionPresModel[] + ParameterId["AttributeDimensionList"] = "attributeDimensionList"; + // DPI_AttributeDimension, having type AttributeDimensionPresModel + ParameterId["AttributeDimension"] = "attributeDimension"; + // DPI_AttributeAttributeDimensionList, having type AttributeDimensionPresModel[] + ParameterId["AttributeAttributeDimensionList"] = "attributeAttributeDimensionList"; + // DPI_StandardDimension, having type StandardDimensionPresModel + ParameterId["StandardDimension"] = "standardDimension"; + // DPI_RelationalTable, having type RelationalTablePresModel + ParameterId["RelationalTable"] = "relationalTable"; + // DPI_DrillPath, having type DrillPathPresModel + ParameterId["DrillPath"] = "drillPath"; + // DPI_FieldFolder, having type FieldFolderPresModel + ParameterId["FieldFolder"] = "fieldFolder"; + // DPI_Group, having type GroupPresModel + ParameterId["Group"] = "group"; + // DPI_UserDefinedAttributeList, having type GroupPresModel[] + ParameterId["UserDefinedAttributeList"] = "userDefinedAttributeList"; + // DPI_Hierarchy, having type HierarchyPresModel + ParameterId["Hierarchy"] = "hierarchy"; + // DPI_HierarchyList, having type HierarchyPresModel[] + ParameterId["HierarchyList"] = "hierarchyList"; + // DPI_HierarchyMemberSelectedState, having type HierarchySelect_MemberSelectedStatePresModel + ParameterId["HierarchyMemberSelectedState"] = "hierarchyMemberSelectedState"; + // DPI_HierarchySelectionChanges, having type HierarchySelect_MemberSelectedStatePresModel[] + ParameterId["HierarchySelectionChanges"] = "hierarchySelectionChanges"; + // DPI_DisplayFolder, having type DisplayFolderPresModel + ParameterId["DisplayFolder"] = "displayFolder"; + // DPI_DisplayFolderList, having type DisplayFolderPresModel[] + ParameterId["DisplayFolderList"] = "displayFolderList"; + // DPI_DataSourceLayout, having type DataSourceLayoutPresModel + ParameterId["DataSourceLayout"] = "dataSourceLayout"; + // DPI_BaseDataSource, having type BaseDataSourcePresModel + ParameterId["BaseDataSource"] = "baseDataSource"; + // DPI_BaseDataSources, having type Dictionary(of BaseDataSourcePresModel) + ParameterId["BaseDataSources"] = "baseDataSources"; + // DPI_DataSource, having type DataSourcePresModel + ParameterId["DataSource"] = "dataSource"; + // DPI_DataSources, having type Dictionary(of DataSourcePresModel) + ParameterId["DataSources"] = "dataSources"; + // DPI_SchemaViewerDataSource, having type SchemaViewerDataSourcePresModel + ParameterId["SchemaViewerDataSource"] = "schemaViewerDataSource"; + // DPI_SchemaViewerDataSources, having type Dictionary(of SchemaViewerDataSourcePresModel) + ParameterId["SchemaViewerDataSources"] = "schemaViewerDataSources"; + // DPI_BaseDataSchema, having type BaseDataSchemaPresModel + ParameterId["BaseDataSchema"] = "baseDataSchema"; + // DPI_DataSchema, having type DataSchemaPresModel + ParameterId["DataSchema"] = "dataSchema"; + // DPI_SchemaViewerDataSchema, having type SchemaViewerDataSchemaPresModel + ParameterId["SchemaViewerDataSchema"] = "schemaViewerDataSchema"; + // DPI_SheetListItem, having type SheetListItemPresModel + ParameterId["SheetListItem"] = "sheetListItem"; + // DPI_SheetListItems, having type SheetListItemPresModel[] + ParameterId["SheetListItems"] = "sheetListItems"; + // DPI_SheetList, having type SheetListPresModel + ParameterId["SheetList"] = "sheetList"; + // DPI_SizeModeOption, having type SizeModeOptionPresModel + ParameterId["SizeModeOption"] = "sizeModeOption"; + // DPI_SizeModeOptions, having type SizeModeOptionPresModel[] + ParameterId["SizeModeOptions"] = "sizeModeOptions"; + // DPI_DashboardSizeControl, having type DashboardSizeControlPresModel + ParameterId["DashboardSizeControl"] = "dashboardSizeControl"; + // DPI_DeviceLayoutInfoItem, having type DeviceLayoutInfoItemPresModel + ParameterId["DeviceLayoutInfoItem"] = "deviceLayoutInfoItem"; + // DPI_DeviceLayoutInfoItems, having type DeviceLayoutInfoItemPresModel[] + ParameterId["DeviceLayoutInfoItems"] = "deviceLayoutInfoItems"; + // DPI_DeviceLayoutInfoList, having type DeviceLayoutInfoListPresModel + ParameterId["DeviceLayoutInfoList"] = "deviceLayoutInfoList"; + // DPI_SpecializedDeviceLayoutItem, having type SpecializedDeviceLayoutItemPresModel + ParameterId["SpecializedDeviceLayoutItem"] = "specializedDeviceLayoutItem"; + // DPI_SpecializedDeviceLayoutItems, having type SpecializedDeviceLayoutItemPresModel[] + ParameterId["SpecializedDeviceLayoutItems"] = "specializedDeviceLayoutItems"; + // DPI_SpecializedDeviceLayoutList, having type SpecializedDeviceLayoutListPresModel + ParameterId["SpecializedDeviceLayoutList"] = "specializedDeviceLayoutList"; + // DPI_SizeItem, having type SizeItemPresModel + ParameterId["SizeItem"] = "sizeItem"; + // DPI_SizeItems, having type SizeItemPresModel[] + ParameterId["SizeItems"] = "sizeItems"; + // DPI_DeviceSizesList, having type SizeItemListPresModel + ParameterId["DeviceSizesList"] = "deviceSizesList"; + // DPI_PresetSizesList, having type SizeItemListPresModel + ParameterId["PresetSizesList"] = "presetSizesList"; + // DPI_SizeItemList, having type SizeItemListPresModel + ParameterId["SizeItemList"] = "sizeItemList"; + // DPI_SubstitutionKeyword, having type SubstitutionKeywordPresModel + ParameterId["SubstitutionKeyword"] = "substitutionKeyword"; + // DPI_SubstitutionKeywords, having type SubstitutionKeywordPresModel[] + ParameterId["SubstitutionKeywords"] = "substitutionKeywords"; + // DPI_SubstitutionKeywordSubList, having type SubstitutionKeywordSubListPresModel + ParameterId["SubstitutionKeywordSubList"] = "substitutionKeywordsSublist"; + // DPI_SubstitutionKeywordSubLists, having type SubstitutionKeywordSubListPresModel[] + ParameterId["SubstitutionKeywordSubLists"] = "substitutionKeywordSublists"; + // DPI_SubstitutionKeywordList, having type SubstitutionKeywordListPresModel + ParameterId["SubstitutionKeywordList"] = "substitutionKeywordsList"; + // DPI_DeviceZoneListItem, having type DeviceZoneListItemPresModel + ParameterId["DeviceZoneListItem"] = "deviceZoneListItem"; + // DPI_DeviceZoneListItems, having type DeviceZoneListItemPresModel[] + ParameterId["DeviceZoneListItems"] = "deviceZoneListItems"; + // DPI_DeviceZoneList, having type DeviceZoneListPresModel + ParameterId["DeviceZoneList"] = "deviceZoneList"; + // DPI_ZoneSnapLineListItem, having type ZoneSnapLineListItemPresModel + ParameterId["ZoneSnapLineListItem"] = "snapLineListItem"; + // DPI_OuterHorizontalSnapLines, having type ZoneSnapLineListItemPresModel[] + ParameterId["OuterHorizontalSnapLines"] = "outerHorizontalSnapLines"; + // DPI_OuterVerticalSnapLines, having type ZoneSnapLineListItemPresModel[] + ParameterId["OuterVerticalSnapLines"] = "outerVerticalSnapLines"; + // DPI_InnerHorizontalSnapLines, having type ZoneSnapLineListItemPresModel[] + ParameterId["InnerHorizontalSnapLines"] = "innerHorizontalSnapLines"; + // DPI_InnerVerticalSnapLines, having type ZoneSnapLineListItemPresModel[] + ParameterId["InnerVerticalSnapLines"] = "innerVerticalSnapLines"; + // DPI_ZoneSnapLineList, having type ZoneSnapLineListPresModel + ParameterId["ZoneSnapLineList"] = "snapLineList"; + // DPI_DashboardZoneHierarchy, having type DashboardZoneHierarchyPresModel + ParameterId["DashboardZoneHierarchy"] = "dashboardZoneHierarchy"; + // DPI_DeviceZoneVisibilityListItem, having type DeviceZoneVisibilityListItemPresModel + ParameterId["DeviceZoneVisibilityListItem"] = "deviceZoneVisibilityListItem"; + // DPI_DeviceZoneVisibilityListItems, having type DeviceZoneVisibilityListItemPresModel[] + ParameterId["DeviceZoneVisibilityListItems"] = "deviceZoneVisibilityListItems"; + // DPI_DeviceZoneVisibilityList, having type DeviceZoneVisibilityListPresModel + ParameterId["DeviceZoneVisibilityList"] = "deviceZoneVisibilityList"; + // DPI_WorksheetDataSchema, having type WorksheetDataSchemaPresModel + ParameterId["WorksheetDataSchema"] = "worksheetDataSchema"; + // DPI_WorksheetDataSchemaMap, having type Dictionary(of WorksheetDataSchemaPresModel) + ParameterId["WorksheetDataSchemaMap"] = "worksheetDataSchemaMap"; + // DPI_Shelf, having type ShelfPresModel + ParameterId["Shelf"] = "shelf"; + // DPI_ShelfDetail, having type ShelfPresModel + ParameterId["ShelfDetail"] = "shelfDetail"; + // DPI_ShelfList, having type ShelfPresModel[] + ParameterId["ShelfList"] = "shelfList"; + // DPI_ShelfItem, having type ShelfItemPresModel + ParameterId["ShelfItem"] = "shelfItem"; + // DPI_ShelfItems, having type ShelfItemPresModel[] + ParameterId["ShelfItems"] = "shelfItems"; + // DPI_Shelves, having type ShelvesPresModel + ParameterId["Shelves"] = "shelves"; + // DPI_FieldEncoding, having type FieldEncodingPresModel + ParameterId["FieldEncoding"] = "fieldEncoding"; + // DPI_FieldEncodings, having type FieldEncodingPresModel[] + ParameterId["FieldEncodings"] = "fieldEncodings"; + // DPI_UberTip, having type UberTipPresModel + ParameterId["UberTip"] = "uberTip"; + // DPI_AnalyticsObjectDragInfo, having type AnalyticsObjectDragInfoPresModel + ParameterId["AnalyticsObjectDragInfo"] = "analyticsObjectDragInfo"; + // DPI_TrendLine, having type TrendLinePresModel + ParameterId["TrendLine"] = "trendLine"; + // DPI_TrendLineDialog, having type TrendLineDialogPresModel + ParameterId["TrendLineDialog"] = "trendLineDialog"; + // DPI_TrendLineDescribePresModel, having type TrendLineDescribePresModel + ParameterId["TrendLineDescribePresModel"] = "trendLineDescribePresModel"; + // DPI_TrendLineAOVModelPresModel, having type TrendLineAOVModelPresModel + ParameterId["TrendLineAOVModelPresModel"] = "trendLineAovModelPresModel"; + // DPI_TrendLineAOVModelsPresModel, having type TrendLineAOVModelPresModel[] + ParameterId["TrendLineAOVModelsPresModel"] = "trendModelDescriptionVector"; + // DPI_TrendLineLineCoefficientPresModel, having type TrendLineLineCoefficientPresModel + ParameterId["TrendLineLineCoefficientPresModel"] = "trendLineLineCoefficient"; + // DPI_TrendLineLineCoefficientsPresModel, having type TrendLineLineCoefficientPresModel[] + ParameterId["TrendLineLineCoefficientsPresModel"] = "trendLineLineCoefficientsPresModel"; + // DPI_TrendLineLinesPresModel, having type TrendLineLinesPresModel + ParameterId["TrendLineLinesPresModel"] = "trendLineLinesPresModel"; + // DPI_TrendLineAOVPresModel, having type TrendLineAOVPresModel + ParameterId["TrendLineAOVPresModel"] = "trendLineAnovaPresModel"; + // DPI_ReferenceLine, having type ReferenceLinePresModel + ParameterId["ReferenceLine"] = "referenceLine"; + // DPI_ReferenceLines, having type ReferenceLinePresModel[] + ParameterId["ReferenceLines"] = "referenceLines"; + // DPI_PercentileEditDataValue, having type EditDataValuePresModel + ParameterId["PercentileEditDataValue"] = "percentileEditDataValue"; + // DPI_LimitEditDataValue, having type EditDataValuePresModel + ParameterId["LimitEditDataValue"] = "limitEditDataValue"; + // DPI_ConfidenceLevelCombo, having type EditValueWidgetPresModel + ParameterId["ConfidenceLevelCombo"] = "confidenceLevelCombo"; + // DPI_DistributionQuantilesCombo, having type EditValueWidgetPresModel + ParameterId["DistributionQuantilesCombo"] = "distributionQuantilesLevelCombo"; + // DPI_PercentilesCombo, having type EditValueWidgetPresModel + ParameterId["PercentilesCombo"] = "distributionPercentilesLevelCombo"; + // DPI_NumericBinSizeCombo, having type EditValueWidgetPresModel + ParameterId["NumericBinSizeCombo"] = "numericBinSizeCombo"; + // DPI_FieldPickerField, having type FieldPickerFieldPresModel + ParameterId["FieldPickerField"] = "fieldPickerField"; + // DPI_FieldPickerFields, having type FieldPickerFieldPresModel[] + ParameterId["FieldPickerFields"] = "fieldPickerFields"; + // DPI_FieldPickerCombo, having type FieldPickerComboPresModel + ParameterId["FieldPickerCombo"] = "fieldPickerCombo"; + // DPI_PairedFieldPickerCombo, having type FieldPickerComboPresModel + ParameterId["PairedFieldPickerCombo"] = "pairedFieldPickerCombo"; + // DPI_ReferenceLineEditorPresModel, having type ReferenceLineEditorPresModel + ParameterId["ReferenceLineEditorPresModel"] = "referenceLineEditor"; + // DPI_CloseDataSourceErrorDialogPresModel, having type CloseDataSourceErrorDialogPresModel + ParameterId["CloseDataSourceErrorDialogPresModel"] = "closeDsErrorDialog"; + // DPI_EditReferenceLine, having type EditReferenceLinePresModel + ParameterId["EditReferenceLine"] = "editReferenceLine"; + // DPI_EditReferenceBand, having type EditReferenceBandPresModel + ParameterId["EditReferenceBand"] = "editReferenceBand"; + // DPI_EditDistribution, having type EditDistributionPresModel + ParameterId["EditDistribution"] = "editDistribution"; + // DPI_DistributionPercentages, having type DistributionPercentagesPresModel + ParameterId["DistributionPercentages"] = "distributionPercentages"; + // DPI_DistributionPercentiles, having type DistributionPercentilesPresModel + ParameterId["DistributionPercentiles"] = "distributionPercentiles"; + // DPI_DistributionQuantiles, having type DistributionQuantilesPresModel + ParameterId["DistributionQuantiles"] = "distributionQuantiles"; + // DPI_DistributionStandardDeviation, having type DistributionStandardDeviationPresModel + ParameterId["DistributionStandardDeviation"] = "distributionStddev"; + // DPI_SortIndicators, having type SortIndicatorsPresModel + ParameterId["SortIndicators"] = "sortIndicators"; + // DPI_SortIndicatorRegion, having type SortIndicatorRegionPresModel + ParameterId["SortIndicatorRegion"] = "sortIndicatorRegion"; + // DPI_SortIndicatorRegions, having type SortIndicatorRegionPresModel[] + ParameterId["SortIndicatorRegions"] = "sortIndicatorRegions"; + // DPI_SortIndicatorItem, having type SortIndicatorItemPresModel + ParameterId["SortIndicatorItem"] = "sortIndicatorItem"; + // DPI_SortIndicatorItems, having type SortIndicatorItemPresModel[] + ParameterId["SortIndicatorItems"] = "sortIndicatorItems"; + // DPI_BuilderConfig, having type BuilderConfigPresModel + ParameterId["BuilderConfig"] = "builderConfig"; + // DPI_SheetLayoutInfo, having type SheetLayoutInfoPresModel + ParameterId["SheetLayoutInfo"] = "sheetLayoutInfo"; + // DPI_AreaRect, having type RectanglePresModel + ParameterId["AreaRect"] = "areaRect"; + // DPI_Border, having type RectanglePresModel + ParameterId["Border"] = "borderRect"; + // DPI_BoundsRect, having type RectanglePresModel + ParameterId["BoundsRect"] = "boundsRect"; + // DPI_ButtonRect, having type RectanglePresModel + ParameterId["ButtonRect"] = "buttonRect"; + // DPI_DragRect, having type RectanglePresModel + ParameterId["DragRect"] = "dragRect"; + // DPI_FocusRect, having type RectanglePresModel + ParameterId["FocusRect"] = "focusRect"; + // DPI_ImageTileRect, having type RectanglePresModel + ParameterId["ImageTileRect"] = "tileRect"; + // DPI_ItemRect, having type RectanglePresModel + ParameterId["ItemRect"] = "itemRect"; + // DPI_LabelRect, having type RectanglePresModel + ParameterId["LabelRect"] = "labelRect"; + // DPI_MarkRect, having type RectanglePresModel + ParameterId["MarkRect"] = "markRect"; + // DPI_MarkTooltipRect, having type RectanglePresModel + ParameterId["MarkTooltipRect"] = "markTooltipRect"; + // DPI_MenuButtonRect, having type RectanglePresModel + ParameterId["MenuButtonRect"] = "menuButtonRect"; + // DPI_OutRegionRect, having type RectanglePresModel + ParameterId["OutRegionRect"] = "outRegionRect"; + // DPI_PaneRect, having type RectanglePresModel + ParameterId["PaneRect"] = "paneRect"; + // DPI_PixelExtents, having type RectanglePresModel + ParameterId["PixelExtents"] = "pixelExtents"; + // DPI_RectMaxLabel, having type RectanglePresModel + ParameterId["RectMaxLabel"] = "rectMaxLabel"; + // DPI_RectMinLabel, having type RectanglePresModel + ParameterId["RectMinLabel"] = "rectMinLabel"; + // DPI_RectRamp, having type RectanglePresModel + ParameterId["RectRamp"] = "rectRamp"; + // DPI_RectTitle, having type RectanglePresModel + ParameterId["RectTitle"] = "rectTitle"; + // DPI_RegionRect, having type RectanglePresModel + ParameterId["RegionRect"] = "regionRect"; + // DPI_SelectionRect, having type RectanglePresModel + ParameterId["SelectionRect"] = "selectionRect"; + // DPI_UnusedRect, having type RectanglePresModel + ParameterId["UnusedRect"] = "unusedRect"; + // DPI_ZoneEdgeRect, having type RectanglePresModel + ParameterId["ZoneEdgeRect"] = "zoneEdge"; + // DPI_ZoneEdgeRectPix, having type RectanglePresModel + ParameterId["ZoneEdgeRectPix"] = "zoneEdgePix"; + // DPI_ZoneEdgeRectPp, having type RectanglePresModel + ParameterId["ZoneEdgeRectPp"] = "zoneEdgePp"; + // DPI_UIAutomationLinkRect, having type RectanglePresModel + ParameterId["UIAutomationLinkRect"] = "linkRect"; + // DPI_Borders, having type RectanglePresModel[] + ParameterId["Borders"] = "borderRects"; + // DPI_UIAutomationLinkRects, having type RectanglePresModel[] + ParameterId["UIAutomationLinkRects"] = "linkRects"; + // DPI_DomainExtents, having type DoubleRectanglePresModel + ParameterId["DomainExtents"] = "domainExtents"; + // DPI_MapDomainExtents, having type DoubleRectanglePresModel + ParameterId["MapDomainExtents"] = "mapDomainExtents"; + // DPI_MapLatLongRect, having type MapRectPresModel + ParameterId["MapLatLongRect"] = "mapLatLongRect"; + // DPI_Center, having type PointPresModel + ParameterId["Center"] = "center"; + // DPI_CenterMarkLineBegin, having type PointPresModel + ParameterId["CenterMarkLineBegin"] = "centerMarkLineBegin"; + // DPI_CenterMarkLineEnd, having type PointPresModel + ParameterId["CenterMarkLineEnd"] = "centerMarkLineEnd"; + // DPI_DropLocation, having type PointPresModel + ParameterId["DropLocation"] = "dropLocation"; + // DPI_EndPt, having type PointPresModel + ParameterId["EndPt"] = "endPoint"; + // DPI_GrabLocation, having type PointPresModel + ParameterId["GrabLocation"] = "grabLocation"; + // DPI_GridOrigin, having type PointPresModel + ParameterId["GridOrigin"] = "gridOrigin"; + // DPI_LassoSelectionPoint, having type PointPresModel + ParameterId["LassoSelectionPoint"] = "lassoSelectionPoint"; + // DPI_MenuLocation, having type PointPresModel + ParameterId["MenuLocation"] = "menuLocation"; + // DPI_MoveOffset, having type PointPresModel + ParameterId["MoveOffset"] = "moveOffset"; + // DPI_OverlayAnchor, having type PointPresModel + ParameterId["OverlayAnchor"] = "overlayAnchor"; + // DPI_PanAmount, having type PointPresModel + ParameterId["PanAmount"] = "panAmount"; + // DPI_PanLocation, having type PointPresModel + ParameterId["PanLocation"] = "panLocation"; + // DPI_PaneResolverLocation, having type PointPresModel + ParameterId["PaneResolverLocation"] = "paneResolverLocation"; + // DPI_PixelExtentsOffset, having type PointPresModel + ParameterId["PixelExtentsOffset"] = "extentsOffset"; + // DPI_Point1, having type PointPresModel + ParameterId["Point1"] = "pt1"; + // DPI_Point2, having type PointPresModel + ParameterId["Point2"] = "pt2"; + // DPI_Point3, having type PointPresModel + ParameterId["Point3"] = "pt3"; + // DPI_RegionPoint, having type PointPresModel + ParameterId["RegionPoint"] = "regionPoint"; + // DPI_ScrollOffset, having type PointPresModel + ParameterId["ScrollOffset"] = "scrollOffset"; + // DPI_SelectAtPoint, having type PointPresModel + ParameterId["SelectAtPoint"] = "selectAtPoint"; + // DPI_SelectOffset, having type PointPresModel + ParameterId["SelectOffset"] = "selectOffset"; + // DPI_TargetPt, having type PointPresModel + ParameterId["TargetPt"] = "targetPoint"; + // DPI_TextOrigin, having type PointPresModel + ParameterId["TextOrigin"] = "textOrigin"; + // DPI_TooltipAnchorPoint, having type PointPresModel + ParameterId["TooltipAnchorPoint"] = "tooltipAnchorPoint"; + // DPI_TooltipOffset, having type PointPresModel + ParameterId["TooltipOffset"] = "tooltipOffset"; + // DPI_VizLocation, having type PointPresModel + ParameterId["VizLocation"] = "vizLocation"; + // DPI_ZoomAnchorPoint, having type PointPresModel + ParameterId["ZoomAnchorPoint"] = "zoomAnchorPoint"; + // DPI_MenuAnchorPoint, having type PointPresModel + ParameterId["MenuAnchorPoint"] = "menuAnchorPoint"; + // DPI_OverlayAnchors, having type PointPresModel[] + ParameterId["OverlayAnchors"] = "overlayAnchors"; + // DPI_LassoSelection, having type PointPresModel[] + ParameterId["LassoSelection"] = "lassoSelection"; + // DPI_ScrollOffsetPoints, having type PointPresModel[] + ParameterId["ScrollOffsetPoints"] = "scrollOffsetPoints"; + // DPI_RadialSelection, having type CirclePresModel + ParameterId["RadialSelection"] = "radialSelection"; + // DPI_DomainOrigin, having type FloatPointPresModel + ParameterId["DomainOrigin"] = "domainOrigin"; + // DPI_FloatCenter, having type FloatPointPresModel + ParameterId["FloatCenter"] = "floatCenter"; + // DPI_FloatPoint, having type FloatPointPresModel + ParameterId["FloatPoint"] = "floatPoint"; + // DPI_ClientAvailableSpace, having type SizePresModel + ParameterId["ClientAvailableSpace"] = "clientAvailableSpace"; + // DPI_DashboardPortSize, having type SizePresModel + ParameterId["DashboardPortSize"] = "dashboardPort"; + // DPI_LegendSize, having type SizePresModel + ParameterId["LegendSize"] = "legendSize"; + // DPI_StoryPortSize, having type SizePresModel + ParameterId["StoryPortSize"] = "storyPort"; + // DPI_SwatchAreaSize, having type SizePresModel + ParameterId["SwatchAreaSize"] = "areaSize"; + // DPI_SwatchImageSize, having type SizePresModel + ParameterId["SwatchImageSize"] = "imageSize"; + // DPI_ViewportSize, having type SizePresModel + ParameterId["ViewportSize"] = "viewportSize"; + // DPI_WorksheetPortSize, having type SizePresModel + ParameterId["WorksheetPortSize"] = "worksheetPort"; + // DPI_ResizeEntity, having type ResizeEntityPresModel + ParameterId["ResizeEntity"] = "resizeEntity"; + // DPI_RowResizers, having type ResizeEntityPresModel[] + ParameterId["RowResizers"] = "rowResizers"; + // DPI_ColResizers, having type ResizeEntityPresModel[] + ParameterId["ColResizers"] = "colResizers"; + // DPI_ResizeInfoPresModel, having type ResizeInfoPresModel + ParameterId["ResizeInfoPresModel"] = "resizeInfo"; + // DPI_ServerSheet, having type ServerSheetPresModel + ParameterId["ServerSheet"] = "serverSheet"; + // DPI_ServerSheets, having type ServerSheetPresModel[] + ParameterId["ServerSheets"] = "serverSheets"; + // DPI_SheetInfo, having type SheetInfoPresModel + ParameterId["SheetInfo"] = "sheetInfo"; + // DPI_SheetsInfo, having type SheetInfoPresModel[] + ParameterId["SheetsInfo"] = "sheetsInfo"; + // DPI_ServerWorkbook, having type ServerWorkbookPresModel + ParameterId["ServerWorkbook"] = "serverWorkbook"; + // DPI_PDFExportOptionsPresModel, having type PDFExportOptionsPresModel + ParameterId["PDFExportOptionsPresModel"] = "pdfExport"; + // DPI_ExportFileResultPresModel, having type ExportFileResultPresModel + ParameterId["ExportFileResultPresModel"] = "pdfResult"; + // DPI_PDFSheet, having type PDFSheetPresModel + ParameterId["PDFSheet"] = "pdfSheet"; + // DPI_SheetOptions, having type PDFSheetPresModel[] + ParameterId["SheetOptions"] = "sheetOptions"; + // DPI_ExportLayoutOptions, having type ExportLayoutOptionsPresModel + ParameterId["ExportLayoutOptions"] = "exportLayoutOptions"; + // DPI_DataAlertConditionOperationType, having type DataAlertConditionOperationType + ParameterId["DataAlertConditionOperationType"] = "dataAlertConditionOp"; + // DPI_DataAlertDialogPresModel, having type DataAlertDialogPresModel + ParameterId["DataAlertDialogPresModel"] = "dataAlertDialogPresModel"; + // DPI_DataAlertMeasure, having type DataAlertMeasurePresModel + ParameterId["DataAlertMeasure"] = "dataAlertMeasure"; + // DPI_DataAlertMeasures, having type DataAlertMeasurePresModel[] + ParameterId["DataAlertMeasures"] = "dataAlertMeasures"; + // DPI_DataAlertConstantCondition, having type DataAlertConstantConditionPresModel + ParameterId["DataAlertConstantCondition"] = "dataAlertConstantCondition"; + // DPI_DataAlertDialogMode, having type DataAlertDialogMode + ParameterId["DataAlertDialogMode"] = "dataAlertDialogMode"; + // DPI_LightweightMapOptions, having type LightweightMapOptionsPresModel + ParameterId["LightweightMapOptions"] = "lightweightMapOptions"; + // DPI_DataHighlighter, having type DataHighlighterPresModel + ParameterId["DataHighlighter"] = "dataHighlighter"; + // DPI_DataHighlighterItemSet, having type DataHighlighterItemSetPresModel + ParameterId["DataHighlighterItemSet"] = "dataHighlighterItemSet"; + // DPI_DataHighlighterItem, having type DataHighlighterItemPresModel + ParameterId["DataHighlighterItem"] = "dataHighlighterItem"; + // DPI_DataHighlighterItems, having type DataHighlighterItemPresModel[] + ParameterId["DataHighlighterItems"] = "dataHighlighterItems"; + // DPI_CategoricalLegendLayout, having type CategoricalLegendLayoutPresModel + ParameterId["CategoricalLegendLayout"] = "catLegendLayout"; + // DPI_CategoricalLegend, having type CategoricalLegendPresModel + ParameterId["CategoricalLegend"] = "categoricalLegend"; + // DPI_CategoricalLegends, having type CategoricalLegendPresModel[] + ParameterId["CategoricalLegends"] = "categoricalLegends"; + // DPI_CategoricalColorLegend, having type CategoricalColorLegendPresModel + ParameterId["CategoricalColorLegend"] = "colorLegend"; + // DPI_ColorLegendItem, having type CategoricalColorLegendItemPresModel + ParameterId["ColorLegendItem"] = "colorLegendItem"; + // DPI_ColorLegendItems, having type CategoricalColorLegendItemPresModel[] + ParameterId["ColorLegendItems"] = "colorLegendItems"; + // DPI_CategoricalShapeLegend, having type CategoricalShapeLegendPresModel + ParameterId["CategoricalShapeLegend"] = "categoricalShapeLegend"; + // DPI_ShapeLegendItem, having type CategoricalShapeLegendItemPresModel + ParameterId["ShapeLegendItem"] = "shapeLegendItem"; + // DPI_ShapeLegendItems, having type CategoricalShapeLegendItemPresModel[] + ParameterId["ShapeLegendItems"] = "shapeLegendItems"; + // DPI_CategoricalHighlightLegend, having type CategoricalHighlightLegendPresModel + ParameterId["CategoricalHighlightLegend"] = "categoricalHighlightLegend"; + // DPI_HighlightLegendItem, having type CategoricalLegendItemPresModel + ParameterId["HighlightLegendItem"] = "highlightLegendItem"; + // DPI_HighlightLegendItems, having type CategoricalLegendItemPresModel[] + ParameterId["HighlightLegendItems"] = "highlightLegendItems"; + // DPI_CategoricalSizeLegend, having type CategoricalSizeLegendPresModel + ParameterId["CategoricalSizeLegend"] = "categoricalSizeLegend"; + // DPI_SizeLegendItem, having type CategoricalSizeLegendItemPresModel + ParameterId["SizeLegendItem"] = "sizeLegendItem"; + // DPI_SizeLegendItems, having type CategoricalSizeLegendItemPresModel[] + ParameterId["SizeLegendItems"] = "sizeLegendItems"; + // DPI_CategoricalMapLegend, having type CategoricalMapLegendPresModel + ParameterId["CategoricalMapLegend"] = "categoricalMapLegend"; + // DPI_QuantitativeColorLegend, having type QuantitativeColorLegendPresModel + ParameterId["QuantitativeColorLegend"] = "quantitativeColorLegend"; + // DPI_QuantitativeColorLegends, having type QuantitativeColorLegendPresModel[] + ParameterId["QuantitativeColorLegends"] = "quantitativeColorLegends"; + // DPI_QuantitativeLegendLayout, having type QuantitativeLegendLayoutPresModel + ParameterId["QuantitativeLegendLayout"] = "quantitativeLegendLayout"; + // DPI_ServerRenderedLegend, having type ServerRenderedLegendPresModel + ParameterId["ServerRenderedLegend"] = "serverRenderedLegend"; + // DPI_CategoricalFilter, having type CategoricalFilterPresModel + ParameterId["CategoricalFilter"] = "categoricalFilter"; + // DPI_CategoricalFilterRelational, having type CategoricalFilterRelationalPresModel + ParameterId["CategoricalFilterRelational"] = "categoricalFilterRelational"; + // DPI_CategoricalFilterMemberDomainPage, having type CategoricalFilterMemberDomainPagePresModel + ParameterId["CategoricalFilterMemberDomainPage"] = "categoricalFilterMemberDomainPage"; + // DPI_CategoricalFilterCacheInfo, having type CategoricalFilterCacheInfoPresModel + ParameterId["CategoricalFilterCacheInfo"] = "categoricalFilterCacheInfo"; + // DPI_CategoricalFilterPatternDisplay, having type CategoricalFilterPatternDisplayPresModel + ParameterId["CategoricalFilterPatternDisplay"] = "categoricalFilterPatternDisplay"; + // DPI_CategoricalFilterPatternUpdate, having type CategoricalFilterPatternUpdatePresModel + ParameterId["CategoricalFilterPatternUpdate"] = "categoricalFilterPatternUpdate"; + // DPI_CategoricalFilterConditionDisplay, having type CategoricalFilterConditionDisplayPresModel + ParameterId["CategoricalFilterConditionDisplay"] = "categoricalFilterConditionDisplay"; + // DPI_CategoricalFilterConditionUpdate, having type CategoricalFilterConditionUpdatePresModel + ParameterId["CategoricalFilterConditionUpdate"] = "categoricalFilterConditionUpdate"; + // DPI_CategoricalFilterLimitDisplay, having type CategoricalFilterLimitDisplayPresModel + ParameterId["CategoricalFilterLimitDisplay"] = "categoricalFilterLimitDisplay"; + // DPI_CategoricalFilterLimitUpdate, having type CategoricalFilterLimitUpdatePresModel + ParameterId["CategoricalFilterLimitUpdate"] = "categoricalFilterLimitUpdate"; + // DPI_CategoricalFilterNew, having type CategoricalFilter_NewPresModel + ParameterId["CategoricalFilterNew"] = "categoricalFilterNew"; + // DPI_CategoricalFilterHierarchy, having type CategoricalFilterHierarchyPresModel + ParameterId["CategoricalFilterHierarchy"] = "categoricalFilterHirerarchy"; + // DPI_CategoricalFilterUpdate, having type CategoricalFilterUpdatePresModel + ParameterId["CategoricalFilterUpdate"] = "categoricalFilterUpdate"; + // DPI_CategoricalFilterRelationalState, having type CategoricalFilterRelationalStatePresModel + ParameterId["CategoricalFilterRelationalState"] = "categoricalRelationalState"; + // DPI_CategoricalFilterRelationalUpdatedState, having type CategoricalFilterRelationalStatePresModel + ParameterId["CategoricalFilterRelationalUpdatedState"] = "categoricalRelationalUpdatedState"; + // DPI_CategoricalFilterRelationalDomainInfo, having type CategoricalFilterRelationalDomainInfoPresModel + ParameterId["CategoricalFilterRelationalDomainInfo"] = "categoricalFilterRelationalDomainInfo"; + // DPI_CategoricalFilterRelationalDisplay, having type CategoricalFilterRelationalDisplayPresModel + ParameterId["CategoricalFilterRelationalDisplay"] = "categoricalFilterRelationalDisplay"; + // DPI_ExpressionToken, having type ExpressionTokenPresModel + ParameterId["ExpressionToken"] = "expressionToken"; + // DPI_ExpressionTokens, having type ExpressionTokenPresModel[] + ParameterId["ExpressionTokens"] = "expressionTokens"; + // DPI_FormulaValidation, having type FormulaValidationPresModel + ParameterId["FormulaValidation"] = "formulaValidation"; + // DPI_CaptionedFilterValue, having type FilterValuePresModel + ParameterId["CaptionedFilterValue"] = "captionedFilterValue"; + // DPI_CaptionedRangeMin, having type FilterValuePresModel + ParameterId["CaptionedRangeMin"] = "captionedRangeMin"; + // DPI_CaptionedRangeMax, having type FilterValuePresModel + ParameterId["CaptionedRangeMax"] = "captionedRangeMax"; + // DPI_CaptionedAnchorDate, having type FilterValuePresModel + ParameterId["CaptionedAnchorDate"] = "captionedAnchorDate"; + // DPI_CaptionedFilterValueList, having type FilterValuePresModel[] + ParameterId["CaptionedFilterValueList"] = "captionedFilterValueList"; + // DPI_CategoricalFilterInfo, having type CategoricalFilterInfoPresModel + ParameterId["CategoricalFilterInfo"] = "categoricalFilterInfo"; + // DPI_QuantitativeFilterInfo, having type QuantitativeFilterInfoPresModel + ParameterId["QuantitativeFilterInfo"] = "quantitativeFilterInfo"; + // DPI_RelativeDateFilterInfo, having type RelativeDateFilterInfoPresModel + ParameterId["RelativeDateFilterInfo"] = "relativeDateFilterInfo"; + // DPI_FilterSelectMeasure, having type FilterSelectMeasurePresModel + ParameterId["FilterSelectMeasure"] = "filterSelectMeasure"; + // DPI_FilterListItem, having type FilterListItemPresModel + ParameterId["FilterListItem"] = "filterListItem"; + // DPI_FilterListItems, having type FilterListItemPresModel[] + ParameterId["FilterListItems"] = "filterItems"; + // DPI_FilterFieldInfo, having type FilterFieldInfoPresModel + ParameterId["FilterFieldInfo"] = "filterFieldInfo"; + // DPI_FilterInfo, having type FilterInfoPresModel + ParameterId["FilterInfo"] = "filterInfo"; + // DPI_FiltersInfo, having type FilterInforPresModel[] + ParameterId["FiltersInfo"] = "filtersInfo"; + // DPI_CategoricalDomain, having type CategoricalDomainPresModel + ParameterId["CategoricalDomain"] = "categoricalDomain"; + // DPI_QuantitativeDomain, having type QuantitativeDomainPresModel + ParameterId["QuantitativeDomain"] = "quantitativeDomain"; + // DPI_ValidationResults, having type ValidationResultsPresModel + ParameterId["ValidationResults"] = "validationResults"; + // DPI_DomainMember, having type DomainMemberPresModel + ParameterId["DomainMember"] = "domainMember"; + // DPI_DomainMembers, having type DomainMemberPresModel[] + ParameterId["DomainMembers"] = "domainMembers"; + // DPI_QuickFilterDisplay, having type QuickFilterDisplayPresModel + ParameterId["QuickFilterDisplay"] = "quickFilterDisplay"; + // DPI_QuickFilter, having type QuickFilterPresModel + ParameterId["QuickFilter"] = "quickFilter"; + // DPI_QuantitativeQuickFilter, having type QuantitativeQuickFilterPresModel + ParameterId["QuantitativeQuickFilter"] = "quantitativeQuickFilter"; + // DPI_RelativeDateQuickFilter, having type RelativeDateQuickFilterPresModel + ParameterId["RelativeDateQuickFilter"] = "relativeDateQuickFilter"; + // DPI_CategoricalQuickFilter, having type CategoricalQuickFilterPresModel + ParameterId["CategoricalQuickFilter"] = "categoricalQuickFilter"; + // DPI_HierarchicalQuickFilter, having type HierarchicalQuickFilterPresModel + ParameterId["HierarchicalQuickFilter"] = "hierarchicalQuickFilter"; + // DPI_DomainTable, having type DomainTablePresModel + ParameterId["DomainTable"] = "domainTable"; + // DPI_DomainTables, having type DomainTablePresModel[] + ParameterId["DomainTables"] = "domainTables"; + // DPI_DomainTuples, having type Tuples + ParameterId["DomainTuples"] = "domainTuples"; + // DPI_SearchTuples, having type Tuples + ParameterId["SearchTuples"] = "searchTuples"; + // DPI_SelectedTuples, having type TupleHash + ParameterId["SelectedTuples"] = "selectedTuples"; + // DPI_PendingTuples, having type TupleHash + ParameterId["PendingTuples"] = "pendingTuples"; + // DPI_Domain, having type MultiDomain + ParameterId["Domain"] = "domain"; + // DPI_DateOption, having type DateBinDialogOptionPresModel + ParameterId["DateOption"] = "dateOption"; + // DPI_DateOptions, having type DateBinDialogOptionPresModel[] + ParameterId["DateOptions"] = "dateOptions"; + // DPI_FilterRangeAdd, having type FilterRangePresModel + ParameterId["FilterRangeAdd"] = "filterRangeAdd"; + // DPI_FilterRangeRemove, having type FilterRangePresModel + ParameterId["FilterRangeRemove"] = "filterRangeRemove"; + // DPI_FilterOptions, having type FilterOptionsPresModel + ParameterId["FilterOptions"] = "filterOptions"; + // DPI_Layer, having type LayerPresModel + ParameterId["Layer"] = "layer"; + // DPI_Layers, having type LayerPresModel[] + ParameterId["Layers"] = "layers"; + // DPI_MarksCardPresModel, having type MarksCardPresModel + ParameterId["MarksCardPresModel"] = "marksCardPresModel"; + // DPI_UIItem, having type UIItemPresModel + ParameterId["UIItem"] = "uiItem"; + // DPI_EncodingUIItem, having type EncodingUIItemPresModel + ParameterId["EncodingUIItem"] = "encodingUiItem"; + // DPI_EncodingUIItems, having type EncodingUIItemPresModel[] + ParameterId["EncodingUIItems"] = "encodingUiItems"; + // DPI_PrimTypeUIItem, having type PrimitiveTypeUIItemPresModel + ParameterId["PrimTypeUIItem"] = "primitiveTypeUiItem"; + // DPI_PrimTypeUIItems, having type PrimitiveTypeUIItemPresModel[] + ParameterId["PrimTypeUIItems"] = "primitiveTypeUiItems"; + // DPI_PrimitiveTypeUIItemOptions, having type PrimitiveTypeUIItemOptionsPresModel + ParameterId["PrimitiveTypeUIItemOptions"] = "primitiveTypeUiItemOptions"; + // DPI_LineUIItemOptions, having type LineUIItemOptionsPresModel + ParameterId["LineUIItemOptions"] = "lineUiItemOptions"; + // DPI_LineInterpolationModeUIItem, having type LineInterpolationModeUIItemPresModel + ParameterId["LineInterpolationModeUIItem"] = "lineInterpolationModeUiItem"; + // DPI_LineInterpolationModeUIItemSet, having type LineInterpolationModeUIItemPresModel[] + ParameterId["LineInterpolationModeUIItemSet"] = "lineInterpolationModeUiItemSet"; + // DPI_LineMarkerPositionUIItem, having type LineMarkerPositionUIItemPresModel + ParameterId["LineMarkerPositionUIItem"] = "lineMarkerPositionUiItem"; + // DPI_LineMarkerPositionUIItemSet, having type LineMarkerPositionUIItemPresModel[] + ParameterId["LineMarkerPositionUIItemSet"] = "lineMarkerPositionUiItemSet"; + // DPI_MarksCardDropdownItem, having type MarksCardDropdownItemPresModel + ParameterId["MarksCardDropdownItem"] = "marksCardDropdownItem"; + // DPI_TooltipDropdownItem, having type TooltipDropdownItemPresModel + ParameterId["TooltipDropdownItem"] = "tooltipDropdownItem"; + // DPI_TextDropdownItem, having type TextDropdownItemPresModel + ParameterId["TextDropdownItem"] = "textDropdownItem"; + // DPI_ColorDropdownItem, having type ColorDropdownItemPresModel + ParameterId["ColorDropdownItem"] = "colorDropdownItem"; + // DPI_SizeSliderPresModel, having type SizeSliderPresModel + ParameterId["SizeSliderPresModel"] = "sizeSliderPresModel"; + // DPI_InflectionPoint, having type InflectionPointPresModel + ParameterId["InflectionPoint"] = "inflectionPoint"; + // DPI_InflectionPoints, having type InflectionPointPresModel[] + ParameterId["InflectionPoints"] = "inflectionPoints"; + // DPI_Notch, having type NotchPresModel + ParameterId["Notch"] = "notch"; + // DPI_Notches, having type NotchPresModel[] + ParameterId["Notches"] = "notches"; + // DPI_MarkSizeOptionsPresModel, having type MarkSizeOptionsPresModel + ParameterId["MarkSizeOptionsPresModel"] = "markSizeOptionsPresModel"; + // DPI_ModifyMarksInSet, having type AddOrRemoveMarks + ParameterId["ModifyMarksInSet"] = "addOrRemoveMarks"; + // DPI_MarkLabelsSpecification, having type MarkLabelsSpecificationPresModel + ParameterId["MarkLabelsSpecification"] = "markLabelsSpecification"; + // DPI_ColorPalette, having type ColorPalettePresModel + ParameterId["ColorPalette"] = "colorPalette"; + // DPI_SelectedColorPalette, having type ColorPalettePresModel + ParameterId["SelectedColorPalette"] = "selectedColorPalette"; + // DPI_ColorPalettes, having type ColorPalettePresModel[] + ParameterId["ColorPalettes"] = "colorPalettes"; + // DPI_ColorPaletteGroup, having type ColorPaletteGroupPresModel + ParameterId["ColorPaletteGroup"] = "colorPaletteGroup"; + // DPI_CatColorPaletteGroups, having type ColorPaletteGroupPresModel[] + ParameterId["CatColorPaletteGroups"] = "catColorPaletteGroups"; + // DPI_QColorPaletteGroups, having type ColorPaletteGroupPresModel[] + ParameterId["QColorPaletteGroups"] = "qColorPaletteGroups"; + // DPI_ColorPaletteCollection, having type ColorPaletteCollectionPresModel + ParameterId["ColorPaletteCollection"] = "colorPaletteCollection"; + // DPI_QuantitativeColor, having type QuantitativeColorPresModel + ParameterId["QuantitativeColor"] = "quantitativeColor"; + // DPI_CategoricalColor, having type CategoricalColorPresModel + ParameterId["CategoricalColor"] = "categoricalColor"; + // DPI_ItemColorPair, having type ItemColorPairPresModel + ParameterId["ItemColorPair"] = "itemColorPair"; + // DPI_ItemColorPairs, having type ItemColorPairPresModel[] + ParameterId["ItemColorPairs"] = "itemColorPairs"; + // DPI_VQLCommandResponse, having type VQLCommandResponsePresModel + ParameterId["VQLCommandResponse"] = "vqlCmdResponse"; + // DPI_LayoutStatus, having type LayoutStatusPresModel + ParameterId["LayoutStatus"] = "layoutStatus"; + // DPI_VizState, having type VizStatePresModel + ParameterId["VizState"] = "vizState"; + // DPI_VizStateList, having type VizStatePresModel[] + ParameterId["VizStateList"] = "vizStateList"; + // DPI_CommandResult, having type CommandResultPresModel + ParameterId["CommandResult"] = "cmdResult"; + // DPI_CommandResultList, having type CommandResultPresModel[] + ParameterId["CommandResultList"] = "cmdResultList"; + // DPI_URLAction, having type URLActionPresModel + ParameterId["URLAction"] = "urlAction"; + // DPI_URLActionList, having type URLActionPresModel[] + ParameterId["URLActionList"] = "urlActionList"; + // DPI_LegacyMenu, having type LegacyMenuPresModel + ParameterId["LegacyMenu"] = "legacyMenu"; + // DPI_LegacyMenus, having type LegacyMenuPresModel[] + ParameterId["LegacyMenus"] = "legacyMenus"; + // DPI_ConnectionAttemptInfo, having type ConnectionAttemptInfoPresModel + ParameterId["ConnectionAttemptInfo"] = "connectionAttemptInfo"; + // DPI_DataSourceConnectionAttemptInfo, having type DataSourceConnectionAttemptInfoPresModel + ParameterId["DataSourceConnectionAttemptInfo"] = "dataSourceConnectionAttemptInfo"; + // DPI_DataSourceConnectionAttemptInfos, having type DataSourceConnectionAttemptInfoPresModel[] + ParameterId["DataSourceConnectionAttemptInfos"] = "dataSourceConnectionAttemptInfos"; + // DPI_CommandValidationPresModel, having type CommandValidationPresModel + ParameterId["CommandValidationPresModel"] = "commandValidationPresModel"; + // DPI_WarningMessage, having type WarningMessagePresModel + ParameterId["WarningMessage"] = "warningMessagePresModel"; + // DPI_ApplicationPresModel, having type ApplicationPresModel + ParameterId["ApplicationPresModel"] = "applicationPresModel"; + // DPI_ToolbarPresModel, having type ToolbarPresModel + ParameterId["ToolbarPresModel"] = "toolbarPresModel"; + // DPI_WorkbookPresModel, having type WorkbookPresModel + ParameterId["WorkbookPresModel"] = "workbookPresModel"; + // DPI_ServerFonts, having type ServerFontsPresModel + ParameterId["ServerFonts"] = "serverFonts"; + // DPI_PublishDataSourceMetadataPresModel, having type PublishDataSourceMetadataPresModel + ParameterId["PublishDataSourceMetadataPresModel"] = "publishDataSourceMetadataPresModel"; + // DPI_DashboardPresModel, having type DashboardPresModel + ParameterId["DashboardPresModel"] = "dashboardPresModel"; + // DPI_DashboardSizePresModel, having type DashboardSizePresModel + ParameterId["DashboardSizePresModel"] = "dashboardSizePresModel"; + // DPI_DashboardSizeWithValidationPresModel, having type DashboardSizeWithValidationPresModel + ParameterId["DashboardSizeWithValidationPresModel"] = "dashboardSizeWithValidationPresModel"; + // DPI_DashboardInfoPresModel, having type DashboardInfoPresModel + ParameterId["DashboardInfoPresModel"] = "dashboardInfoPresModel"; + // DPI_VisualPresModel, having type VisualPresModel + ParameterId["VisualPresModel"] = "visual"; + // DPI_VisualPresModels, having type VisualPresModel[] + ParameterId["VisualPresModels"] = "visuals"; + // DPI_DropLinesPresModel, having type DropLinesPresModel + ParameterId["DropLinesPresModel"] = "dropLinesPresModel"; + // DPI_DropFieldPresModel, having type DropFieldPresModel + ParameterId["DropFieldPresModel"] = "dropFieldPresModel"; + // DPI_DropFieldResultPresModel, having type DropFieldResultPresModel + ParameterId["DropFieldResultPresModel"] = "dropFieldResultPresModel"; + // DPI_CurrentAxisRange, having type DataValueRangePresModel + ParameterId["CurrentAxisRange"] = "currentAxisRange"; + // DPI_CurrentAxisRangeNoTime, having type DataValueRangePresModel + ParameterId["CurrentAxisRangeNoTime"] = "currentAxisRangeNoTime"; + // DPI_DefaultAxisRange, having type DataValueRangePresModel + ParameterId["DefaultAxisRange"] = "defaultAxisRange"; + // DPI_NewAxisRange, having type DataValueRangePresModel + ParameterId["NewAxisRange"] = "newAxisRange"; + // DPI_AxisOptions, having type AxisOptionsPresModel + ParameterId["AxisOptions"] = "axis"; + // DPI_AxisMajorTicks, having type TickMarkInfoPresModel + ParameterId["AxisMajorTicks"] = "axisMajorTicks"; + // DPI_AxisMinorTicks, having type TickMarkInfoPresModel + ParameterId["AxisMinorTicks"] = "axisMinorTicks"; + // DPI_EditAxisDialog, having type EditAxisDialogPresModel + ParameterId["EditAxisDialog"] = "editAxisDialog"; + // DPI_MarkLabels, having type ScenePresModel + ParameterId["MarkLabels"] = "markLabels"; + // DPI_Scene, having type ScenePresModel + ParameterId["Scene"] = "scene"; + // DPI_MapServer, having type MapServerPresModel + ParameterId["MapServer"] = "mapServer"; + // DPI_VisualList, having type VisualListPresModel + ParameterId["VisualList"] = "visualList"; + // DPI_DrawFirst, having type VisualListPresModel[] + ParameterId["DrawFirst"] = "drawFirst"; + // DPI_DrawLast, having type VisualListPresModel[] + ParameterId["DrawLast"] = "drawLast"; + // DPI_DrawPane, having type VisualListPresModel[] + ParameterId["DrawPane"] = "drawPane"; + // DPI_UserPaneInfo, having type UserPaneInfoPresModel + ParameterId["UserPaneInfo"] = "userPaneInfo"; + // DPI_AnalyticsPane, having type AnalyticsPanePresModel + ParameterId["AnalyticsPane"] = "analyticsPane"; + // DPI_AnalyticsObjectItem, having type AnalyticsObjectItemPresModel + ParameterId["AnalyticsObjectItem"] = "analyticsObjectItem"; + // DPI_AnalyticsObjectItems, having type AnalyticsObjectItemPresModel[] + ParameterId["AnalyticsObjectItems"] = "analyticsObjectItems"; + // DPI_AnalyticsObjectGroup, having type AnalyticsObjectGroupPresModel + ParameterId["AnalyticsObjectGroup"] = "analyticsObjectGroup"; + // DPI_AnalyticsObjectGroups, having type AnalyticsObjectGroupPresModel[] + ParameterId["AnalyticsObjectGroups"] = "analyticsObjectGroups"; + // DPI_DropZoneItem, having type DropZoneItemPresModel + ParameterId["DropZoneItem"] = "dropZoneItem"; + // DPI_DropZoneItems, having type DropZoneItemPresModel[] + ParameterId["DropZoneItems"] = "dropZoneItems"; + // DPI_DropTargetInfo, having type DropTargetInfoPresModel + ParameterId["DropTargetInfo"] = "dropTargetInfo"; + // DPI_Pane, having type PanePresModel + ParameterId["Pane"] = "pane"; + // DPI_Panes, having type PanePresModel[] + ParameterId["Panes"] = "panes"; + // DPI_RadialSelectionDistanceInfo, having type RadialSelectionDistanceInfoPresModel + ParameterId["RadialSelectionDistanceInfo"] = "radialSelectionDistanceInfo"; + // DPI_MapScaleInfo, having type MapScaleInfoPresModel + ParameterId["MapScaleInfo"] = "mapScaleInfo"; + // DPI_RenderNode, having type RenderNodePresModel + ParameterId["RenderNode"] = "renderNode"; + // DPI_RenderNodes, having type RenderNodePresModel[] + ParameterId["RenderNodes"] = "renderNodes"; + // DPI_PredictionBand, having type PredictionBandPresModel + ParameterId["PredictionBand"] = "predictionBand"; + // DPI_PredictionWhisker, having type PredictionWhiskerPresModel + ParameterId["PredictionWhisker"] = "predictionWhisker"; + // DPI_DrawGroup, having type DrawPointsPresModel + ParameterId["DrawGroup"] = "drawGroup"; + // DPI_ClipReset, having type DrawItemPresModel + ParameterId["ClipReset"] = "clipReset"; + // DPI_DrawItem, having type DrawItemPresModel + ParameterId["DrawItem"] = "drawItem"; + // DPI_TransformPop, having type DrawItemPresModel + ParameterId["TransformPop"] = "transformPop"; + // DPI_TransformPush, having type DrawItemPresModel + ParameterId["TransformPush"] = "transformPush"; + // DPI_DrawItems, having type DrawItemPresModel[] + ParameterId["DrawItems"] = "drawItems"; + // DPI_ClipRect, having type DrawPointsPresModel + ParameterId["ClipRect"] = "clipRect"; + // DPI_DrawEllipse, having type DrawPointsPresModel + ParameterId["DrawEllipse"] = "drawEllipse"; + // DPI_DrawFillEllipse, having type DrawPointsPresModel + ParameterId["DrawFillEllipse"] = "drawFillEllipse"; + // DPI_DrawFillPolygon, having type DrawPointsPresModel + ParameterId["DrawFillPolygon"] = "drawFillPolygon"; + // DPI_DrawFillRect, having type DrawPointsPresModel + ParameterId["DrawFillRect"] = "drawFillRect"; + // DPI_DrawPolygon, having type DrawPointsPresModel + ParameterId["DrawPolygon"] = "drawPolygon"; + // DPI_DrawPolyline, having type DrawPointsPresModel + ParameterId["DrawPolyline"] = "drawPolyline"; + // DPI_DrawRect, having type DrawPointsPresModel + ParameterId["DrawRect"] = "drawRect"; + // DPI_DrawFillPath, having type DrawPathPresModel + ParameterId["DrawFillPath"] = "drawFillPath"; + // DPI_DrawPath, having type DrawPathPresModel + ParameterId["DrawPath"] = "drawPath"; + // DPI_DrawText, having type DrawTextPresModel + ParameterId["DrawText"] = "drawText"; + // DPI_DrawImage, having type DrawImagePresModel + ParameterId["DrawImage"] = "drawImage"; + // DPI_ImageTileInfo, having type ImageTileInfoPresModel + ParameterId["ImageTileInfo"] = "tileInfo"; + // DPI_ImageTileInfos, having type ImageTileInfoPresModel[] + ParameterId["ImageTileInfos"] = "tileInfos"; + // DPI_DrawImageTiles, having type DrawImageTilesPresModel + ParameterId["DrawImageTiles"] = "drawImageTiles"; + // DPI_DrawPen, having type DrawPenPresModel + ParameterId["DrawPen"] = "drawPen"; + // DPI_DrawSolidBrush, having type DrawSolidBrushPresModel + ParameterId["DrawSolidBrush"] = "drawSolidBrush"; + // DPI_DrawTextProperties, having type DrawTextPropertiesPresModel + ParameterId["DrawTextProperties"] = "drawTextProps"; + // DPI_DrawGradientBrush, having type DrawGradientBrushPresModel + ParameterId["DrawGradientBrush"] = "drawGradientBrush"; + // DPI_DrawTransform, having type DrawTransformPresModel + ParameterId["DrawTransform"] = "transform"; + // DPI_DrawAntialias, having type DrawAntialiasPresModel + ParameterId["DrawAntialias"] = "drawAntialias"; + // DPI_ImageDictionary, having type ImageDictionaryPresModel + ParameterId["ImageDictionary"] = "imageDictionary"; + // DPI_ColorDictionary, having type ColorDictionaryPresModel + ParameterId["ColorDictionary"] = "colorDictionary"; + // DPI_MarkShape, having type MarkShapePresModel + ParameterId["MarkShape"] = "markShape"; + // DPI_MarkShapeList, having type MarkShapePresModel[] + ParameterId["MarkShapeList"] = "markShapeList"; + // DPI_PaneDescriptor, having type PaneDescriptorPresModel + ParameterId["PaneDescriptor"] = "paneDescriptor"; + // DPI_PDMarks, having type PDMarksPresModel + ParameterId["PDMarks"] = "pdMarks"; + // DPI_PDMarksMap, having type Dictionary(of PDMarksPresModel) + ParameterId["PDMarksMap"] = "pdMarksMap"; + // DPI_LabelTextTable, having type LabelTextTable + ParameterId["LabelTextTable"] = "labelTextTable"; + // DPI_TextTableHelper, having type TextTableHelper + ParameterId["TextTableHelper"] = "textTableHelper"; + // DPI_GeometryTable, having type GeometryTable + ParameterId["GeometryTable"] = "geometryTable"; + // DPI_PaneMarks, having type PaneMarksPresModel + ParameterId["PaneMarks"] = "paneMarks"; + // DPI_PaneMarksList, having type PaneMarksPresModel[] + ParameterId["PaneMarksList"] = "paneMarksList"; + // DPI_BrushingSelection, having type SelectionPresModel + ParameterId["BrushingSelection"] = "brushing"; + // DPI_Selection, having type SelectionPresModel + ParameterId["Selection"] = "selection"; + // DPI_BrushingSelectionList, having type SelectionPresModel[] + ParameterId["BrushingSelectionList"] = "brushingSelectionList"; + // DPI_SelectionList, having type SelectionPresModel[] + ParameterId["SelectionList"] = "selectionList"; + // DPI_ShelfSelectionModel, having type ShelfSelectionPresModel + ParameterId["ShelfSelectionModel"] = "shelfSelectionModel"; + // DPI_ShelfSelectionModels, having type ShelfSelectionPresModel[] + ParameterId["ShelfSelectionModels"] = "shelfSelectionModels"; + // DPI_ShelfSelectionsModel, having type ShelfSelectionsPresModel + ParameterId["ShelfSelectionsModel"] = "shelfSelectionsModel"; + // DPI_DimValSelectionModel, having type DimensionValueSelectionPresModel + ParameterId["DimValSelectionModel"] = "dimensionValueSelectionModel"; + // DPI_DimValSelectionModels, having type DimensionValueSelectionPresModel[] + ParameterId["DimValSelectionModels"] = "dimensionValueSelectionModels"; + // DPI_HierValSelectionModel, having type HierarchicalValueSelectionPresModel + ParameterId["HierValSelectionModel"] = "hierarchicalValueSelectionModel"; + // DPI_HierValSelectionModels, having type HierarchicalValueSelectionPresModel[] + ParameterId["HierValSelectionModels"] = "hierarchicalValueSelectionModels"; + // DPI_QuantRangeSelectionModel, having type QuantativeRangeSelectionPresModel + ParameterId["QuantRangeSelectionModel"] = "quantativeRangeSelectionModel"; + // DPI_QuantRangeSelectionModels, having type QuantativeRangeSelectionPresModel[] + ParameterId["QuantRangeSelectionModels"] = "quantativeRangeSelectionModels"; + // DPI_QuantValueSelectionModel, having type QuantativeValueSelectionPresModel + ParameterId["QuantValueSelectionModel"] = "quantativeValueSelectionModel"; + // DPI_QuantValueSelectionModels, having type QuantativeValueSelectionPresModel[] + ParameterId["QuantValueSelectionModels"] = "quantativeValueSelectionModels"; + // DPI_LegendSelectionInfo, having type LegendSelectionInfoPresModel + ParameterId["LegendSelectionInfo"] = "legendSelectionInfo"; + // DPI_NodeReference, having type NodeReferencePresModel + ParameterId["NodeReference"] = "nodeReference"; + // DPI_PageReference, having type PageReferencePresModel + ParameterId["PageReference"] = "pageReference"; + // DPI_OrientedNodeReference, having type OrientedNodeReferencePresModel + ParameterId["OrientedNodeReference"] = "orientedNodeReference"; + // DPI_OrientedNodeReferences, having type OrientedNodeReferencePresModel[] + ParameterId["OrientedNodeReferences"] = "orientedNodeReferences"; + // DPI_SelectionData, having type SelectionDataPresModel + ParameterId["SelectionData"] = "selectionData"; + // DPI_HighlightedData, having type HighlightedDataPresModel + ParameterId["HighlightedData"] = "highlightedData"; + // DPI_Node, having type NodePresModel + ParameterId["Node"] = "node"; + // DPI_Nodes, having type NodePresModel[] + ParameterId["Nodes"] = "nodes"; + // DPI_SelectedNodes, having type NodePresModel[] + ParameterId["SelectedNodes"] = "selectedNodes"; + // DPI_UserAction, having type ActionPresModel + ParameterId["UserAction"] = "userAction"; + // DPI_UserActions, having type ActionPresModel[] + ParameterId["UserActions"] = "userActions"; + // DPI_LinkSpec, having type LinkSpecPresModel + ParameterId["LinkSpec"] = "linkSpec"; + // DPI_ActionSpecificationModel, having type ActionSpecificationPresModel + ParameterId["ActionSpecificationModel"] = "actionSpecification"; + // DPI_LinkSpecification, having type LinkSpecificationPresModel + ParameterId["LinkSpecification"] = "linkSpecification"; + // DPI_ScriptDescription, having type ScriptDescriptionPresModel + ParameterId["ScriptDescription"] = "scriptDescription"; + // DPI_ActionSource, having type ActionSourcePresModel + ParameterId["ActionSource"] = "actionSource"; + // DPI_FieldExprItem, having type FieldExprItemPresModel + ParameterId["FieldExprItem"] = "fieldExpressionItem"; + // DPI_FieldExprVector, having type FieldExprItemPresModel[] + ParameterId["FieldExprVector"] = "fieldExpressionVector"; + // DPI_ActionComboItem, having type ActionComboItemPresModel + ParameterId["ActionComboItem"] = "actionComboItem"; + // DPI_ActionComboVector, having type ActionComboItemPresModel[] + ParameterId["ActionComboVector"] = "actionComboVector"; + // DPI_ActionSourceCombo, having type ActionSourceComboPresModel + ParameterId["ActionSourceCombo"] = "actionSourceCombo"; + // DPI_ActionDestCombo, having type ActionComboPresModel + ParameterId["ActionDestCombo"] = "actionDestCombo"; + // DPI_ActionFieldList, having type ActionFieldListPresModel + ParameterId["ActionFieldList"] = "actionFieldList"; + // DPI_EditBrushAction, having type EditBrushActionPresModel + ParameterId["EditBrushAction"] = "editBrushAction"; + // DPI_UpdateActionSource, having type UpdateActionSourcePresModel + ParameterId["UpdateActionSource"] = "updateActionSource"; + // DPI_UpdateBrushAction, having type UpdateBrushActionPresModel + ParameterId["UpdateBrushAction"] = "updateBrushAction"; + // DPI_ActionWarnings, having type ActionWarningsPresModel + ParameterId["ActionWarnings"] = "actionWarnings"; + // DPI_EditHyperlinkAction, having type EditHyperlinkActionPresModel + ParameterId["EditHyperlinkAction"] = "editHyperlinkAction"; + // DPI_UpdateHyperlinkAction, having type UpdateHyperlinkActionPresModel + ParameterId["UpdateHyperlinkAction"] = "updateHyperlinkAction"; + // DPI_EditSheetLinkAction, having type EditSheetLinkActionPresModel + ParameterId["EditSheetLinkAction"] = "editSheetlinkAction"; + // DPI_UpdateSheetLinkAction, having type UpdateSheetLinkActionPresModel + ParameterId["UpdateSheetLinkAction"] = "updateSheetlinkAction"; + // DPI_ActionItem, having type ActionItemPresModel + ParameterId["ActionItem"] = "actionItem"; + // DPI_ActionItemList, having type ActionItemPresModel[] + ParameterId["ActionItemList"] = "actionItemList"; + // DPI_DataSegment, having type DataSegmentPresModel + ParameterId["DataSegment"] = "dataSegment"; + // DPI_DataSegments, having type Dictionary(of DataSegmentPresModel) + ParameterId["DataSegments"] = "dataSegments"; + // DPI_DataDictionary, having type DataDictionaryPresModel + ParameterId["DataDictionary"] = "dataDictionary"; + // DPI_VizData, having type VizDataPresModel + ParameterId["VizData"] = "vizData"; + // DPI_VizColumn, having type VizColumnPresModel + ParameterId["VizColumn"] = "vizColumn"; + // DPI_VizColumns, having type VizColumnPresModel[] + ParameterId["VizColumns"] = "vizColumns"; + // DPI_VizDataColumn, having type VizDataColumnPresModel + ParameterId["VizDataColumn"] = "vizDataColumn"; + // DPI_VizDataColumns, having type VizDataColumnPresModel[] + ParameterId["VizDataColumns"] = "vizDataColumns"; + // DPI_VizPaneColumn, having type VizPaneColumnPresModel + ParameterId["VizPaneColumn"] = "vizPaneColumn"; + // DPI_VizPaneColumns, having type VizPaneColumnPresModel[] + ParameterId["VizPaneColumns"] = "vizPaneColumns"; + // DPI_PaneColumns, having type PaneColumnsPresModel + ParameterId["PaneColumns"] = "paneColumns"; + // DPI_PaneColumnsList, having type PaneColumnsPresModel[] + ParameterId["PaneColumnsList"] = "paneColumnsList"; + // DPI_PaneColumnsData, having type PaneColumnsDataPresModel + ParameterId["PaneColumnsData"] = "paneColumnsData"; + // DPI_FilterContext, having type FilterContextPresModel + ParameterId["FilterContext"] = "filterContext"; + // DPI_UberTipPaneData, having type UberTipPaneDataPresModel + ParameterId["UberTipPaneData"] = "ubertipPaneData"; + // DPI_UberTipPaneDatas, having type UberTipPaneDataPresModel[] + ParameterId["UberTipPaneDatas"] = "ubertipPaneDatas"; + // DPI_UberTipData, having type UberTipDataPresModel + ParameterId["UberTipData"] = "ubertipData"; + // DPI_RefLineTip, having type RefLineTipPresModel + ParameterId["RefLineTip"] = "refLineTip"; + // DPI_RefLineTips, having type RefLineTipPresModel[] + ParameterId["RefLineTips"] = "refLineTips"; + // DPI_NumericBin, having type NumericBinPresModel + ParameterId["NumericBin"] = "numericBin"; + // DPI_NumericBinDialog, having type NumericBinDialogPresModel + ParameterId["NumericBinDialog"] = "numericBinDialog"; + // DPI_DomainRange, having type DomainRangePresModel + ParameterId["DomainRange"] = "domainRange"; + // DPI_BinSizeInfo, having type BinSizeInfoPresModel + ParameterId["BinSizeInfo"] = "binSizeInfo"; + // DPI_DetailedErrorDialog, having type DetailedErrorPresModel + ParameterId["DetailedErrorDialog"] = "detailedErrorDialog"; + // DPI_DragSourcePosition, having type ShelfDropPositionPresModel + ParameterId["DragSourcePosition"] = "shelfDragSourcePosition"; + // DPI_DropTargetPosition, having type ShelfDropPositionPresModel + ParameterId["DropTargetPosition"] = "shelfDropTargetPosition"; + // DPI_ShelfDropPosition, having type ShelfDropPositionPresModel + ParameterId["ShelfDropPosition"] = "shelfDropPosition"; + // DPI_ShelfDropPositions, having type ShelfDropPositionPresModel[] + ParameterId["ShelfDropPositions"] = "shelfDropPositions"; + // DPI_ShelfDropModel, having type ShelfDropPresModel + ParameterId["ShelfDropModel"] = "shelfDropModel"; + // DPI_ShelfDropModels, having type ShelfDropPresModel[] + ParameterId["ShelfDropModels"] = "shelfDropModels"; + // DPI_Drag, having type DragPresModel + ParameterId["Drag"] = "drag"; + // DPI_SceneElement, having type SceneElementPresModel + ParameterId["SceneElement"] = "sceneElement"; + // DPI_SceneElements, having type SceneElementPresModel[] + ParameterId["SceneElements"] = "sceneElements"; + // DPI_QuickFilterType, having type QuickFilterType + ParameterId["QuickFilterType"] = "quickFilterType"; + // DPI_CatMode, having type QuickFilterCategoricalMode + ParameterId["CatMode"] = "categoricalMode"; + // DPI_CatCtrl, having type QuickFilterCategoricalCtrl + ParameterId["CatCtrl"] = "categoricalControl"; + // DPI_QuantMode, having type QuickFilterQuantitativeMode + ParameterId["QuantMode"] = "quantitativeMode"; + // DPI_QuantCtrl, having type QuickFilterQuantitativeCtrl + ParameterId["QuantCtrl"] = "quantitativeControl"; + // DPI_ZoneCommon, having type ZoneCommonPresModel + ParameterId["ZoneCommon"] = "zoneCommon"; + // DPI_ZoneCommonListItems, having type ZoneCommonPresModel[] + ParameterId["ZoneCommonListItems"] = "zoneCommonListItems"; + // DPI_Zone, having type ZonePresModel + ParameterId["Zone"] = "zone"; + // DPI_Zones, having type Dictionary(of ZonePresModel) + ParameterId["Zones"] = "zones"; + // DPI_ImageZone, having type ImageZonePresModel + ParameterId["ImageZone"] = "imageZone"; + // DPI_WebZone, having type WebZonePresModel + ParameterId["WebZone"] = "webZone"; + // DPI_AddInZone, having type AddInZonePresModel + ParameterId["AddInZone"] = "addInZone"; + // DPI_ButtonZonePresModel, having type ButtonZonePresModel + ParameterId["ButtonZonePresModel"] = "buttonZone"; + // DPI_ButtonConfigDialog, having type ButtonConfigDialogPresModel + ParameterId["ButtonConfigDialog"] = "buttonConfigDialog"; + // DPI_ZoneEdgeMoveType, having type ZoneEdgeMove + ParameterId["ZoneEdgeMoveType"] = "zoneEdgeMoveType"; + // DPI_ZoneSide, having type SideType + ParameterId["ZoneSide"] = "zoneSide"; + // DPI_SnapPoint, having type SnapPointPresModel + ParameterId["SnapPoint"] = "snapPoint"; + // DPI_SnapPoints, having type SnapPointPresModel[] + ParameterId["SnapPoints"] = "snapPoints"; + // DPI_TargetPreviewPair, having type DragDropTargetPreviewPairPresModel + ParameterId["TargetPreviewPair"] = "targetPreviewPair"; + // DPI_TargetPreviewPairs, having type DragDropTargetPreviewPairPresModel[] + ParameterId["TargetPreviewPairs"] = "targetPreviewPairs"; + // DPI_ContainerGuide, having type DragDropContainerGuidePresModel + ParameterId["ContainerGuide"] = "containerGuide"; + // DPI_ContainerGuides, having type DragDropContainerGuidePresModel[] + ParameterId["ContainerGuides"] = "containerGuides"; + // DPI_ZoneBorder, having type DragDropZoneBorderPresModel + ParameterId["ZoneBorder"] = "zoneBorder"; + // DPI_ZoneBorders, having type DragDropZoneBorderPresModel[] + ParameterId["ZoneBorders"] = "zoneBorders"; + // DPI_DashboardDragDrop, having type DashboardDragDropPresModel + ParameterId["DashboardDragDrop"] = "zoneDragDrop"; + // DPI_DragZoneResize, having type DragZoneResizePresModel + ParameterId["DragZoneResize"] = "zoneResize"; + // DPI_DashboardText, having type TextRegionPresModel + ParameterId["DashboardText"] = "dashboardText"; + // DPI_DashboardTitle, having type TextRegionPresModel + ParameterId["DashboardTitle"] = "dashboardTitle"; + // DPI_QuickFilterTitle, having type TextRegionPresModel + ParameterId["QuickFilterTitle"] = "quickFilterTitle"; + // DPI_VisualCaption, having type TextRegionPresModel + ParameterId["VisualCaption"] = "visualCaption"; + // DPI_VisualTitle, having type TextRegionPresModel + ParameterId["VisualTitle"] = "visualTitle"; + // DPI_ZoneTitleRegion, having type TextRegionPresModel + ParameterId["ZoneTitleRegion"] = "zoneTitle"; + // DPI_ForecastOptions, having type ForecastPresModel + ParameterId["ForecastOptions"] = "forecastOptions"; + // DPI_ForecastDescription, having type ForecastDescribePresModel + ParameterId["ForecastDescription"] = "forecastDescription"; + // DPI_WorkgroupPublishObject, having type WorkgroupPublishObjectPresModel + ParameterId["WorkgroupPublishObject"] = "publishDataSource"; + // DPI_PublishPermissionsSummary, having type PublishPermissionsSummaryPresModel + ParameterId["PublishPermissionsSummary"] = "publishPermissionsSummary"; + // DPI_CheckNameResults, having type CheckNameResultsPresModel + ParameterId["CheckNameResults"] = "checkNameResults"; + // DPI_ValidatePublishViewsResult, having type ValidatePublishViewsResultPresModel + ParameterId["ValidatePublishViewsResult"] = "validatePublishViewsResult"; + // DPI_PublishAuthenticationSettings, having type PublishAuthenticationSettingsPresModel + ParameterId["PublishAuthenticationSettings"] = "publishAuthenticationSettings"; + // DPI_ManageDatasources, having type ManageDatasourcesPresModel + ParameterId["ManageDatasources"] = "manageDatasources"; + // DPI_CredentialsAuthSettings, having type CredentialsAuthSettingsPresModel + ParameterId["CredentialsAuthSettings"] = "credentialsAuthSettings"; + // DPI_ConnectionCredentialsAuthSettings, having type ConnectionCredentialsAuthSettingsPresModel + ParameterId["ConnectionCredentialsAuthSettings"] = "connectionCredentialsAuthSettings"; + // DPI_ConnectionCredentialsAuthSettingsList, having type ConnectionCredentialsAuthSettingsPresModel[] + ParameterId["ConnectionCredentialsAuthSettingsList"] = "connectionCredentialsAuthSettingsList"; + // DPI_PublishDatasourceFromWorkbookInfo, having type PublishDatasourceFromWorkbookInfoPresModel + ParameterId["PublishDatasourceFromWorkbookInfo"] = "publishDatasourceFromWorkbookInfo"; + // DPI_PublishDatasourcesFromWorkbookInfo, having type PublishDatasourceFromWorkbookInfoPresModel[] + ParameterId["PublishDatasourcesFromWorkbookInfo"] = "publishDatasourcesFromWorkbookInfo"; + // DPI_PublishSheet, having type PublishSheetPresModel + ParameterId["PublishSheet"] = "publishSheet"; + // DPI_PublishSheets, having type PublishSheetPresModel[] + ParameterId["PublishSheets"] = "publishSheets"; + // DPI_PublishObjectViews, having type PublishObjectViewsPresModel + ParameterId["PublishObjectViews"] = "publishObjectViews"; + // DPI_PublishObjectPublishSheetResults, having type PublishObjectPublishSheetResultsPresModel + ParameterId["PublishObjectPublishSheetResults"] = "publishObjectPublishSheetResults"; + // DPI_RefreshExtractSchedulingSettings, having type RefreshExtractSchedulingSettingsPresModel + ParameterId["RefreshExtractSchedulingSettings"] = "refreshExtractSchedulingSettings"; + // DPI_SetRefreshExtractScheduleResult, having type SetRefreshExtractScheduleResultPresModel + ParameterId["SetRefreshExtractScheduleResult"] = "setRefreshExtractScheduleResult"; + // DPI_CheckPublishObjectNameWarningsResults, having type CheckPublishObjectNameWarningsResultsPresModel + ParameterId["CheckPublishObjectNameWarningsResults"] = "checkPublishObjectNameWarningsResults"; + // DPI_PublishDatasourceOnWorkbookPublishResults, having type PublishDatasourceOnWorkbookPublishResultsPresModel + ParameterId["PublishDatasourceOnWorkbookPublishResults"] = "publishDatasourceOnWorkbookPublishResult"; + // DPI_PublishDataSourceResult, having type PublishDataSourceResultPresModel + ParameterId["PublishDataSourceResult"] = "publishDataSourceResult"; + // DPI_PublishWarningMessage, having type PublishWarningMessagePresModel + ParameterId["PublishWarningMessage"] = "publishWarningMessage"; + // DPI_MustDowngradeToPublishWarningMessagePresModel, having type PublishWarningMessagePresModel + ParameterId["MustDowngradeToPublishWarningMessagePresModel"] = "mustDowngradeToPublishWarningMessagePresModel"; + // DPI_PublishSelectedAttributes, having type PublishSelectedAttributesPresModel + ParameterId["PublishSelectedAttributes"] = "publishSelectedAttributes"; + // DPI_AutosaveFile, having type AutosaveFilePresModel + ParameterId["AutosaveFile"] = "autosaveFile"; + // DPI_AutosaveFiles, having type AutosaveFilePresModel[] + ParameterId["AutosaveFiles"] = "autosaveFiles"; + // DPI_FunctionGroup, having type FunctionGroup + ParameterId["FunctionGroup"] = "funcGrp"; + // DPI_FunctionGroups, having type FunctionGroup[] + ParameterId["FunctionGroups"] = "funcGrps"; + // DPI_FunctionArgType, having type FunctionArgType + ParameterId["FunctionArgType"] = "funcArgType"; + // DPI_FunctionArgTypes, having type FunctionArgType[] + ParameterId["FunctionArgTypes"] = "funcArgTypes"; + // DPI_CalculationStyle, having type CalcStyle + ParameterId["CalculationStyle"] = "calculationStyle"; + // DPI_Calculation, having type CalculationPresModel + ParameterId["Calculation"] = "calculation"; + // DPI_TypeInPill, having type CalculationPresModel + ParameterId["TypeInPill"] = "typeInPill"; + // DPI_CalcErrorInfo, having type CalcErrorInfoPresModel + ParameterId["CalcErrorInfo"] = "errorInfo"; + // DPI_CalcErrorInfos, having type CalcErrorInfoPresModel[] + ParameterId["CalcErrorInfos"] = "errorInfoList"; + // DPI_CalcualtionValidation, having type CalculationValidationPresModel + ParameterId["CalcualtionValidation"] = "calculationValidation"; + // DPI_ExpressionFunction, having type ExpressionFunctionPresModel + ParameterId["ExpressionFunction"] = "expressionFunc"; + // DPI_ExpressionFunctions, having type ExpressionFunctionPresModel[] + ParameterId["ExpressionFunctions"] = "expressionFuncList"; + // DPI_ExpressionFunctionsPM, having type ExpressionFunctionsPresModel + ParameterId["ExpressionFunctionsPM"] = "expressionFuncPm"; + // DPI_StyleToken, having type StyleTokenPresModel + ParameterId["StyleToken"] = "styleToken"; + // DPI_StyleTokens, having type StyleTokenPresModel[] + ParameterId["StyleTokens"] = "styleTokenList"; + // DPI_CalcEditorTextSelection, having type CalcEditorTextSelectionPresModel + ParameterId["CalcEditorTextSelection"] = "calcEditorTextSelection"; + // DPI_AutoCompleteItemType, having type AutoCompleteItemType + ParameterId["AutoCompleteItemType"] = "autocompleteType"; + // DPI_AutoCompleteItem, having type AutoCompleteItemPresModel + ParameterId["AutoCompleteItem"] = "autocompleteItem"; + // DPI_AutoCompleteItems, having type AutoCompleteItemPresModel[] + ParameterId["AutoCompleteItems"] = "autocompleteItemList"; + // DPI_CalculationAutoCompleteContextMenu, having type CalculationAutoCompleteContextMenuPresModel + ParameterId["CalculationAutoCompleteContextMenu"] = "calculationAutocompleteContextMenu"; + // DPI_CalcApplyResult, having type CalcApplyResult + ParameterId["CalcApplyResult"] = "calculationApplyResult"; + // DPI_RampBorderStyledBox, having type StyledBoxPresModel + ParameterId["RampBorderStyledBox"] = "rampBorderStyledBox"; + // DPI_StyledBox, having type StyledBoxPresModel + ParameterId["StyledBox"] = "styledBox"; + // DPI_GlobalStyledBox, having type StyledBoxPresModel + ParameterId["GlobalStyledBox"] = "globalStyledBox"; + // DPI_StyleContext, having type StyleContextPresModel + ParameterId["StyleContext"] = "styleContext"; + // DPI_CurrentTextStyle, having type TextStylePresModel + ParameterId["CurrentTextStyle"] = "currentTextStyle"; + // DPI_LabelTextStyle, having type TextStylePresModel + ParameterId["LabelTextStyle"] = "labelTextStyle"; + // DPI_OriginalTextStyle, having type TextStylePresModel + ParameterId["OriginalTextStyle"] = "originalTextStyle"; + // DPI_SelectedTextStyleModel, having type TextStylePresModel + ParameterId["SelectedTextStyleModel"] = "selectedTextStyleModel"; + // DPI_SwatchTextStyleModel, having type TextStylePresModel + ParameterId["SwatchTextStyleModel"] = "swatchTextStyle"; + // DPI_TextStyleModel, having type TextStylePresModel + ParameterId["TextStyleModel"] = "textStyle"; + // DPI_TitleStyleModel, having type TextStylePresModel + ParameterId["TitleStyleModel"] = "titleStyleModel"; + // DPI_PropertyBag, having type PropertyBagPresModel + ParameterId["PropertyBag"] = "propBagWrapper"; + // DPI_PresModelMap, having type Dictionary(of PropertyBagPresModel) + ParameterId["PresModelMap"] = "presModelMap"; + // DPI_PresentationLayerNotifications, having type PresModelMapPresModel + ParameterId["PresentationLayerNotifications"] = "presentationLayerNotifications"; + // DPI_SecondaryInfo, having type PresModelMapPresModel + ParameterId["SecondaryInfo"] = "secondaryInfo"; + // DPI_ClientDashboardUIMetric, having type ClientDashboardUIMetricPresModel + ParameterId["ClientDashboardUIMetric"] = "clientDashboardUiMetric"; + // DPI_ClientDashboardUIMetrics, having type ClientDashboardUIMetricPresModel[] + ParameterId["ClientDashboardUIMetrics"] = "clientDashboardUiMetrics"; + // DPI_ClientDashboardUIMetricContainer, having type ClientDashboardUIMetricContainerPresModel + ParameterId["ClientDashboardUIMetricContainer"] = "clientDashboardUiMetricContainer"; + // DPI_ExtSvcConfig, having type ExtSvcConfigPresModel + ParameterId["ExtSvcConfig"] = "extSvcConfig"; + // DPI_StoryboardSheetItem, having type StoryboardSheetItemPresModel + ParameterId["StoryboardSheetItem"] = "storyboardSheetItem"; + // DPI_StoryboardSheetItems, having type StoryboardSheetItemPresModel[] + ParameterId["StoryboardSheetItems"] = "storyboardSheetItems"; + // DPI_StoryboardSheetList, having type StoryboardSheetListPresModel + ParameterId["StoryboardSheetList"] = "storyboardSheetList"; + // DPI_FitToStoryBoardOptionItem, having type FitToStoryBoardOptionItemPresModel + ParameterId["FitToStoryBoardOptionItem"] = "fitToStoryboardOptionItem"; + // DPI_FitToStoryBoardOptionItems, having type FitToStoryBoardOptionItemPresModel[] + ParameterId["FitToStoryBoardOptionItems"] = "fitToStoryboardOptionItems"; + // DPI_FitToStoryBoardOptionList, having type FitToStoryBoardOptionListPresModel + ParameterId["FitToStoryBoardOptionList"] = "fitToStoryboardOptionList"; + // DPI_StoryPointNavItem, having type StoryPointNavItemPresModel + ParameterId["StoryPointNavItem"] = "storypointNavItem"; + // DPI_StoryPointNavItems, having type StoryPointNavItemPresModel[] + ParameterId["StoryPointNavItems"] = "storypointNavItems"; + // DPI_FlipboardNav, having type FlipboardNavPresModel + ParameterId["FlipboardNav"] = "flipboardNav"; + // DPI_ScrollBarStyle, having type ScrollBarStylePresModel + ParameterId["ScrollBarStyle"] = "scrollBarStyle"; + // DPI_DashboardZoneLayoutPane, having type DashboardZoneLayoutPanePresModel + ParameterId["DashboardZoneLayoutPane"] = "dashboardZoneLayoutPane"; + // DPI_SelectedStoryPointStyle, having type StoryPointCaptionStylePresModel + ParameterId["SelectedStoryPointStyle"] = "selectedStoryPointStyle"; + // DPI_UnselectedStoryPointStyle, having type StoryPointCaptionStylePresModel + ParameterId["UnselectedStoryPointStyle"] = "unselectedStoryPointStyle"; + // DPI_FlipboardNavStyle, having type FlipboardNavStylePresModel + ParameterId["FlipboardNavStyle"] = "flipboardNavStyle"; + // DPI_StoryPoint, having type StoryPointPresModel + ParameterId["StoryPoint"] = "storyPoint"; + // DPI_StoryPoints, having type Dictionary(of StoryPointPresModel) + ParameterId["StoryPoints"] = "storyPoints"; + // DPI_Flipboard, having type FlipboardPresModel + ParameterId["Flipboard"] = "flipboard"; + // DPI_StoryPair, having type StoryPairPresModel + ParameterId["StoryPair"] = "storyPair"; + // DPI_StoryPairs, having type StoryPairPresModel[] + ParameterId["StoryPairs"] = "storyPairs"; + // DPI_StoryboardPM, having type StoryboardPresModel + ParameterId["StoryboardPM"] = "storyboardPm"; + // DPI_HiDpiIconDictionary, having type ImageCollectionPresModel + ParameterId["HiDpiIconDictionary"] = "hiDpiIconDictionary"; + // DPI_IconDictionary, having type ImageCollectionPresModel + ParameterId["IconDictionary"] = "iconDictionary"; + // DPI_IconResourceDictionary, having type ImageResourceCollectionPresModel + ParameterId["IconResourceDictionary"] = "iconResDictionary"; + // DPI_DataPreviewWindowMessage, having type DataPreviewWindowMessagePresModel + ParameterId["DataPreviewWindowMessage"] = "dataPreviewWindowMessage"; + // DPI_DataSourceData, having type DataSourceDataPresModel + ParameterId["DataSourceData"] = "dataSrcData"; + // DPI_DataSourceSort, having type DataSourceSortPresModel + ParameterId["DataSourceSort"] = "dataSrcSort"; + // DPI_ColumnInfo, having type DSColumnInfoPresModel + ParameterId["ColumnInfo"] = "columnInfo"; + // DPI_ColumnInfos, having type DSColumnInfoPresModel[] + ParameterId["ColumnInfos"] = "columnInfos"; + // DPI_DataFormatter, having type DVFormatter + ParameterId["DataFormatter"] = "dataFormatter"; + // DPI_JoinDescription, having type JoinDescriptionPresModel + ParameterId["JoinDescription"] = "joinDescription"; + // DPI_JoinDescriptions, having type Dictionary(of JoinDescriptionPresModel) + ParameterId["JoinDescriptions"] = "joinDescriptions"; + // DPI_FileTableInfo, having type FileTableInfoPresModel + ParameterId["FileTableInfo"] = "fileTableInfo"; + // DPI_FieldMapping, having type FieldMappingPresModel + ParameterId["FieldMapping"] = "fieldMapping"; + // DPI_FieldMappingData, having type FieldMappingDataPresModel + ParameterId["FieldMappingData"] = "fieldMappingData"; + // DPI_FieldMappingDataVector, having type FieldMappingDataPresModel[] + ParameterId["FieldMappingDataVector"] = "fieldMappingDataVector"; + // DPI_FrameFinder, having type FrameFinderPresModel + ParameterId["FrameFinder"] = "frameFinder"; + // DPI_SheetLinkFieldMapping, having type SheetLinkFieldMappingPresModel + ParameterId["SheetLinkFieldMapping"] = "sheetLinkFieldMapping"; + // DPI_UnionInfo, having type UnionInfoPresModel + ParameterId["UnionInfo"] = "unionInfo"; + // DPI_UnionTableInfo, having type UnionTableInfoPresMode + ParameterId["UnionTableInfo"] = "unionTableInfo"; + // DPI_UnionTableInfos, having type UnionTableInfoPresModel[] + ParameterId["UnionTableInfos"] = "unionTableInfos"; + // DPI_ConnectionPBUnionInfo, having type PBUnionInfoPresModel + ParameterId["ConnectionPBUnionInfo"] = "connectionPbunionInfo"; + // DPI_ConnectionPBUnionInfos, having type PBUnionInfoPresModel[] + ParameterId["ConnectionPBUnionInfos"] = "connectionPbunionInfos"; + // DPI_JoinClause, having type JoinClausePresModel + ParameterId["JoinClause"] = "joinClause"; + // DPI_JoinClauses, having type JoinClausePresModel[] + ParameterId["JoinClauses"] = "joinClauses"; + // DPI_JoinValidationResult, having type JoinValidationResultPresModel + ParameterId["JoinValidationResult"] = "joinValidationResult"; + // DPI_JoinTableInfo, having type JoinTableInfoPresModel + ParameterId["JoinTableInfo"] = "joinTableInfo"; + // DPI_ParameterInfo, having type JoinTableInfoPresModel + ParameterId["ParameterInfo"] = "parameterInfo"; + // DPI_JoinTableInfos, having type JoinTableInfoPresModel[] + ParameterId["JoinTableInfos"] = "joinTableInfos"; + // DPI_JoinOnCalcInfo, having type JoinOnCalcInfoPresModel + ParameterId["JoinOnCalcInfo"] = "joinOnCalcInfo"; + // DPI_ConnectionSummary, having type ConnectionSummaryPresModel + ParameterId["ConnectionSummary"] = "connectionSummary"; + // DPI_ConnectionSummaries, having type ConnectionSummaryPresModel[] + ParameterId["ConnectionSummaries"] = "connectionSummaries"; + // DPI_TopLevelConnectionDescription, having type TopLevelConnectionDescriptionPresModel + ParameterId["TopLevelConnectionDescription"] = "topLevelConnectionDescription"; + // DPI_DataConnectionTableViewMessages, having type DataConnectionTableViewMessagesPresModel + ParameterId["DataConnectionTableViewMessages"] = "dataConnectionTableViewMessages"; + // DPI_TextTransformScript, having type TextTransformScriptPresModel + ParameterId["TextTransformScript"] = "textTransformScript"; + // DPI_CalendarDateOptions, having type CalendarDateOptionsPresModel + ParameterId["CalendarDateOptions"] = "calendarDateOptions"; + // DPI_GoToWorksheetTooltipPresModel, having type GoToWorksheetTooltipPresModel + ParameterId["GoToWorksheetTooltipPresModel"] = "goToWorksheetTooltipPresModel"; + // DPI_TableCleaningPresModel, having type TableCleaningPresModel + ParameterId["TableCleaningPresModel"] = "tableCleaningPresModel"; + // DPI_PivotPresModel, having type PivotPresModel + ParameterId["PivotPresModel"] = "pivotPresModel"; + // DPI_PivotTreeItemPresModel, having type PivotTreeItemPresModel + ParameterId["PivotTreeItemPresModel"] = "pivotTreeItemPresModel"; + // DPI_PivotTreeItems, having type PivotTreeItemPresModel[] + ParameterId["PivotTreeItems"] = "pivotTreeItemsPresModel"; + // DPI_PivotDisplay, having type PivotDisplayPresModel + ParameterId["PivotDisplay"] = "pivotDisplay"; + // DPI_PivotTag, having type NameColumnsPairPresModel + ParameterId["PivotTag"] = "pivotTag"; + // DPI_PivotGroups, having type NameColumnsPairPresModel[] + ParameterId["PivotGroups"] = "pivotGroups"; + // DPI_DataSourceDropdown, having type DataSourceDropdownPresModel + ParameterId["DataSourceDropdown"] = "dataSourceDropdown"; + // DPI_ConnectionDropdown, having type ConnectionDropdownPresModel + ParameterId["ConnectionDropdown"] = "connectionDropdown"; + // DPI_ActivityEvent, having type ActivityEventPresModel + ParameterId["ActivityEvent"] = "activityEvent"; + // DPI_UIAutomation, having type UIAutomationPresModel + ParameterId["UIAutomation"] = "uiAutomation"; + // DPI_UIAutomationIndex, having type UIAutomationIndexPresModel + ParameterId["UIAutomationIndex"] = "uiAutomationIndex"; + // DPI_UIAutomationIndexList, having type UIAutomationIndexPresModel[] + ParameterId["UIAutomationIndexList"] = "uiAutomationIndexList"; + // DPI_UIAutomationComponentInfo, having type UIAutomationComponentInfoPresModel + ParameterId["UIAutomationComponentInfo"] = "uiAutomationComponentInfo"; + // DPI_UIAutomationComponentInfoList, having type UIAutomationComponentInfoPresModel[] + ParameterId["UIAutomationComponentInfoList"] = "uiAutomationComponentInfoList"; + // DPI_Geometry, having type GeometryPresModel + ParameterId["Geometry"] = "geometry"; + // DPI_MultiPoint, having type MultiPointPresModel + ParameterId["MultiPoint"] = "multiPoint"; + // DPI_MultiLine, having type MultiLinePresModel + ParameterId["MultiLine"] = "multiLine"; + // DPI_MultiPolygon, having type MultiPolygonPresModel + ParameterId["MultiPolygon"] = "multiPolygon"; + // DPI_Polygon, having type PolygonPresModel + ParameterId["Polygon"] = "polygon"; + // DPI_PolygonList, having type PolygonPresModel[] + ParameterId["PolygonList"] = "polygonList"; + // DPI_Line, having type LinePresModel + ParameterId["Line"] = "line"; + // DPI_LineList, having type LinePresModel[] + ParameterId["LineList"] = "lineList"; + // DPI_TabbedAuthentication, having type TabbedAuthenticationPresModel + ParameterId["TabbedAuthentication"] = "tabbedAuthentication"; + // DPI_TabbedAuthenticationTabInfo, having type TabbedAuthenticationTabInfoPresModel + ParameterId["TabbedAuthenticationTabInfo"] = "tabbedAuthenticationTabInfo"; + // DPI_TabbedAuthenticationTabInfos, having type TabbedAuthenticationTabInfoPresModel[] + ParameterId["TabbedAuthenticationTabInfos"] = "tabbedAuthenticationTabInfos"; + // DPI_GeographicSearchCandidate, having type GeographicSearchCandidatePresModel + ParameterId["GeographicSearchCandidate"] = "geographicSearchCandidate"; + // DPI_GeographicSearchCandidateList, having type GeographicSearchCandidatePresModel[] + ParameterId["GeographicSearchCandidateList"] = "geographicSearchCandidateList"; + // DPI_GeographicSearchResults, having type GeographicSearchPresModel + ParameterId["GeographicSearchResults"] = "geographicSearchResults"; + // DPI_ParamInfo, having type ParameterInfoPresModel + ParameterId["ParamInfo"] = "paramInfo"; + // DPI_ParamInfos, having type ParameterInfoPresModel[] + ParameterId["ParamInfos"] = "paramInfos"; + // DPI_ParamNamespaceInfo, having type ParameterNamespaceInfoInfoPresModel + ParameterId["ParamNamespaceInfo"] = "paramNamespaceInfo"; + // DPI_ParamNamespaceInfos, having type ParameterNamespaceInfoPresModel[] + ParameterId["ParamNamespaceInfos"] = "paramNamespaceInfos"; + // DPI_ParamRegistryInfo, having type ParameterRegistryInfoPresModel + ParameterId["ParamRegistryInfo"] = "paramRegistryInfo"; + // DPI_DataSourceProperties, having type DataSourcePropertiesPresModel + ParameterId["DataSourceProperties"] = "connectionProperties"; + // DPI_ConnectionTypePresModel, having type ConnectionTypePresModel + ParameterId["ConnectionTypePresModel"] = "connectionTypePresModel"; + // DPI_ConnectionTypes, having type ConnectionTypePresModel[] + ParameterId["ConnectionTypes"] = "connectionTypes"; + // DPI_ConnectionTypeGroupPresModel, having type ConnectionTypeGroupPresModel + ParameterId["ConnectionTypeGroupPresModel"] = "connectionTypeGroupPresModel"; + // DPI_SavedDataSourcePresModel, having type SavedDataSourcePresModel + ParameterId["SavedDataSourcePresModel"] = "savedDatasourcePresModel"; + // DPI_SavedDataSources, having type SavedDataSourcePresModel[] + ParameterId["SavedDataSources"] = "savedDatasources"; + // DPI_SavedDataSourcesPresModel, having type SavedDataSourcesPresModel + ParameterId["SavedDataSourcesPresModel"] = "savedDatasourcesPresModel"; + // DPI_OpenPaneItemPresModel, having type OpenPaneItemPresModel + ParameterId["OpenPaneItemPresModel"] = "openPaneItemPresModel"; + // DPI_OpenPaneItems, having type OpenPaneItemPresModel[] + ParameterId["OpenPaneItems"] = "openPaneItems"; + // DPI_OpenPaneItemsPresModel, having type OpenPaneItemsPresModel + ParameterId["OpenPaneItemsPresModel"] = "openPaneItemsPresModel"; + // DPI_VariableValue, having type VariableValuePresModel + ParameterId["VariableValue"] = "variableValue"; + // DPI_VariableValues, having type VariableValuePresModel[] + ParameterId["VariableValues"] = "variableValues"; + // DPI_ServerVariableValue, having type ServerVariableValuePresModel + ParameterId["ServerVariableValue"] = "serverVariableValue"; + // DPI_EditableVariableValue, having type EditableVariableValuePresModel + ParameterId["EditableVariableValue"] = "editableVariableValue"; + // DPI_ServerVariableMetadata, having type ServerVariableMetadataPresModel + ParameterId["ServerVariableMetadata"] = "serverVariableMetadata"; + // DPI_PromptVariable, having type PromptVariablePresModel + ParameterId["PromptVariable"] = "promptVariable"; + // DPI_PromptVariables, having type PromptVariablePresModel[] + ParameterId["PromptVariables"] = "promptVariables"; + // DPI_VariablePromptDialog, having type VariablePromptDialogPresModel + ParameterId["VariablePromptDialog"] = "variablePromptDialog"; + // DPI_VariableValueOperation, having type VariableValueOperationPresModel + ParameterId["VariableValueOperation"] = "variableValueOperation"; + // DPI_VariableValueOperations, having type VariableValueOperationPresModel[] + ParameterId["VariableValueOperations"] = "variableValueOperations"; + // DPI_TableOptionsPresModel, having type TableOptionsPresModel + ParameterId["TableOptionsPresModel"] = "tableOptionsPresModel"; + // DPI_ClientInfoPresModel, having type ClientInfoPresModel + ParameterId["ClientInfoPresModel"] = "clientInfoPresModel"; + // DPI_TableauFileInfoPresModel, having type TableauFileInfoPresModel + ParameterId["TableauFileInfoPresModel"] = "tableauFileInfoPresModel"; + // DPI_DebuggingInfoPresModel, having type DebuggingInfoPresModel + ParameterId["DebuggingInfoPresModel"] = "debuggingInfoPresModel"; + // DPI_RunningThreadInfoPresModel, having type RunningThreadInfoPresModel + ParameterId["RunningThreadInfoPresModel"] = "runningThreadInfoPresModel"; + // DPI_AboutDialogInfoPresModel, having type AboutDialogInfoPresModel + ParameterId["AboutDialogInfoPresModel"] = "aboutDialogInfoPresModel"; + // DPI_HybridUIShowcasePresModel, having type HybridUIShowcasePresModel + ParameterId["HybridUIShowcasePresModel"] = "hybridUiShowcasePresModel"; + // DPI_MenuConfiguration, having type MenuConfigurationPresModel + ParameterId["MenuConfiguration"] = "menuConfiguration"; + // DPI_MenuItem, having type MenuItemPresModel + ParameterId["MenuItem"] = "menuItem"; + // DPI_MenuItemModels, having type MenuItemPresModel[] + ParameterId["MenuItemModels"] = "menuItemModels"; + // DPI_DefaultTextFormat, having type DefaultTextFormatPresModel + ParameterId["DefaultTextFormat"] = "defaultTextFormat"; + // DPI_MapBoxServerInfoPresModel, having type MapBoxServerInfoPresModel + ParameterId["MapBoxServerInfoPresModel"] = "mapboxServerInfoPresModel"; + // DPI_WMSServerInfoPresModel, having type WMSServerInfoPresModel + ParameterId["WMSServerInfoPresModel"] = "wmsServerInfoPresModel"; + // DPI_MapSourceConflictPresModel, having type MapSourceConflictPresModel + ParameterId["MapSourceConflictPresModel"] = "mapSourceConflictPresModel"; + // DPI_EnumeratedSetDialogPresModel, having type EnumeratedSetDialogPresModel + ParameterId["EnumeratedSetDialogPresModel"] = "enumeratedSetDialogPresModel"; + // DPI_EditAliasesDialog, having type EditAliasesDialogPresModel + ParameterId["EditAliasesDialog"] = "editAliasesDialogPresModel"; + // DPI_AliasesPresModel, having type AliasesPresModel + ParameterId["AliasesPresModel"] = "aliasesPresModel"; + // DPI_ClearAliasesPresModel, having type AliasesPresModel + ParameterId["ClearAliasesPresModel"] = "clearAliasesPresModel"; + // DPI_NewAliasesPresModel, having type NewAliasesPresModel + ParameterId["NewAliasesPresModel"] = "newAliasesPresModel"; + // DPI_AliasPresModel, having type AliasPresModel + ParameterId["AliasPresModel"] = "aliasPresModel"; + // DPI_AliasItem, having type AliasItemPresModel + ParameterId["AliasItem"] = "aliasItem"; + // DPI_DuplicateAliasItem, having type AliasItemPresModel + ParameterId["DuplicateAliasItem"] = "duplicateAliasItem"; + // DPI_AliasList, having type AliasItemPresModel[] + ParameterId["AliasList"] = "aliasList"; + // DPI_AliasResultItem, having type AliasResultItemPresModel + ParameterId["AliasResultItem"] = "aliasResultItem"; + // DPI_AliasResultList, having type AliasResultItemPresModel[] + ParameterId["AliasResultList"] = "aliasResultList"; + // DPI_AliasResults, having type AliasResultsPresModel + ParameterId["AliasResults"] = "aliasResults"; + // DPI_EditSetDialogPresModel, having type EditSetDialogPresModel + ParameterId["EditSetDialogPresModel"] = "editSetDialogPresModel"; + // DPI_ConfirmationPresModel, having type ConfirmationPresModel + ParameterId["ConfirmationPresModel"] = "confirmationPresModel"; + // DPI_NotificationPresModel, having type NotificationPresModel + ParameterId["NotificationPresModel"] = "notificationPresModel"; + // DPI_RetargetDataSourceDialogPresModel, having type RetargetDataSourceDialogPresModel + ParameterId["RetargetDataSourceDialogPresModel"] = "retargetDatasourceDialogPresModel"; + // DPI_SharedFilterPresModel, having type SharedFilterPresModel + ParameterId["SharedFilterPresModel"] = "sharedFilterPresModel"; + // DPI_SharedFilterWorksheetInfo, having type SharedFilterWorksheetInfoPresModel + ParameterId["SharedFilterWorksheetInfo"] = "sharedFilterWorksheetInfo"; + // DPI_SharedFilterWorksheetInfoList, having type SharedFilterWorksheetInfoPresModel[] + ParameterId["SharedFilterWorksheetInfoList"] = "sharedFilterWorksheetInfoList"; + // DPI_FieldPickerTreePresModel, having type FieldPickerTreePresModel + ParameterId["FieldPickerTreePresModel"] = "fieldPickerTreePresModel"; + // DPI_FieldPickerTreePresModelSource, having type FieldPickerTreePresModel + ParameterId["FieldPickerTreePresModelSource"] = "fieldPickerTreePresModelSource"; + // DPI_FieldPickerTreePresModelTarget, having type FieldPickerTreePresModel + ParameterId["FieldPickerTreePresModelTarget"] = "fieldPickerTreePresModelTarget"; + // DPI_ErrorInfo, having type ErrorInfoPresModel + ParameterId["ErrorInfo"] = "errorInfoPresModel"; + // DPI_CustomSplitPresModel, having type CustomSplitPresModel + ParameterId["CustomSplitPresModel"] = "customSplitPresModel"; + // DPI_PageSetup, having type PageSetupPresModel + ParameterId["PageSetup"] = "pageSetup"; + // DPI_ServerConnectStatus, having type ServerConnectionStatus + ParameterId["ServerConnectStatus"] = "serverConnectionStatus"; + // DPI_GetFilterItemsResponse, having type GetFilterItemsResponsePresModel + ParameterId["GetFilterItemsResponse"] = "getFilterItemsResponse"; + // DPI_FilterSearchResponse, having type FilterSearchResponsePresModel + ParameterId["FilterSearchResponse"] = "filterSearchResponse"; + // DPI_FilterSearchWithIndexResponse, having type FilterSearchWithIndexResponsePresModel + ParameterId["FilterSearchWithIndexResponse"] = "filterSearchWithIndexResponse"; + // DPI_FilterShowChildrenResponse, having type FilterShowChildrenResponsePresModel + ParameterId["FilterShowChildrenResponse"] = "filterShowChildrenResponse"; + // DPI_EditDataServerConnection, having type EditDataServerConnectionPresModel + ParameterId["EditDataServerConnection"] = "editDataServerConnection"; + // DPI_ImagesEdit, having type ImagesEditPresModel + ParameterId["ImagesEdit"] = "imagesEdit"; + // DPI_BackgroundImage, having type BackgroundImagePresModel + ParameterId["BackgroundImage"] = "backgroundImage"; + // DPI_BackgroundImages, having type BackgroundImagePresModel[] + ParameterId["BackgroundImages"] = "backgroundImages"; + // DPI_Predicate, having type PredicatePresModel + ParameterId["Predicate"] = "predicate"; + // DPI_Predicates, having type PredicatePresModel[] + ParameterId["Predicates"] = "predicates"; + // DPI_ImagesEditResult, having type ImagesEditResultPresModel + ParameterId["ImagesEditResult"] = "imagesEditResult"; + // DPI_SortDialogPresModel, having type SortDialogPresModel + ParameterId["SortDialogPresModel"] = "sortDialogPresModel"; + // DPI_CompoundTableCalc, having type CompoundTableCalculationPresModel + ParameterId["CompoundTableCalc"] = "compoundTableCalculationPresModel"; + // DPI_TableCalc, having type TableCalculationPresModel + ParameterId["TableCalc"] = "tableCalculationPresModel"; + // DPI_TableCalcs, having type TableCalculationPresModel[] + ParameterId["TableCalcs"] = "tableCalculationPresModels"; + // DPI_TableCalcIdentifier, having type TableCalcIdentifierPresModel + ParameterId["TableCalcIdentifier"] = "tableCalcIdentifier"; + // DPI_NestedTableCalcInfo, having type NestedTableCalcInfoPresModel + ParameterId["NestedTableCalcInfo"] = "nestedTableCalcInfo"; + // DPI_NestedTableCalcInfos, having type NestedTableCalcInfoPresModel[] + ParameterId["NestedTableCalcInfos"] = "nestedTableCalcInfos"; + // DPI_Ordering, having type TableCalcOrderingPresModel + ParameterId["Ordering"] = "tableCalcOrderingPresModel"; + // DPI_Cumulative, having type CumulativeTableCalcPresModel + ParameterId["Cumulative"] = "cumulativeTableCalcPresModel"; + // DPI_ReferenceOptions, having type TableCalcReferenceOptionsPresModel + ParameterId["ReferenceOptions"] = "tableCalcReferenceOptionsPresModel"; + // DPI_Difference, having type DifferenceTableCalcPresModel + ParameterId["Difference"] = "differenceTableCalcPresModel"; + // DPI_Window, having type WindowTableCalcPresModel + ParameterId["Window"] = "windowTableCalcPresModel"; + // DPI_PercentTotal, having type PercentTotalTableCalcPresModel + ParameterId["PercentTotal"] = "percentTotalTableCalcPresModel"; + // DPI_Rank, having type RankTableCalcPresModel + ParameterId["Rank"] = "rankTableCalcPresModel"; + // DPI_Custom, having type CustomTableCalcPresModel + ParameterId["Custom"] = "customTableCalcPresModel"; + // DPI_WebDataUrl, having type WebDataUrlPresModel + ParameterId["WebDataUrl"] = "webDataUrl"; + // DPI_VisitedWebDataConnectors, having type WebDataUrlPresModel[] + ParameterId["VisitedWebDataConnectors"] = "visitedWebDataConnectors"; + // DPI_WebDataSessionUrls, having type WebDataUrlPresModel[] + ParameterId["WebDataSessionUrls"] = "webDataSessionUrls"; + // DPI_WebDataUrls, having type WebDataUrlPresModel[] + ParameterId["WebDataUrls"] = "webDataUrls"; + // DPI_FieldPicker, having type FieldPickerPresModel + ParameterId["FieldPicker"] = "fieldPicker"; + // DPI_DescribeField, having type DescribeFieldPresModel + ParameterId["DescribeField"] = "describeField"; + // DPI_ShowDataPresModel, having type ShowDataPresModel + ParameterId["ShowDataPresModel"] = "showDataPresModel"; + // DPI_DataTablePresModel, having type ShowDataTablePresModel + ParameterId["DataTablePresModel"] = "dataTablePresModel"; + // DPI_DataTablePresModels, having type ShowDataTablePresModel[] + ParameterId["DataTablePresModels"] = "dataTablePresModels"; + // DPI_SummaryTablePresModels, having type ShowDataTablePresModel[] + ParameterId["SummaryTablePresModels"] = "summaryTablePresModels"; + // DPI_RefreshAllExtractsPresModel, having type RefreshAllExtractsPresModel + ParameterId["RefreshAllExtractsPresModel"] = "refeshAllExtractsPresModel"; + // DPI_RefreshExtractDataSourcePresModel, having type RefreshExtractDataSourcePresModel + ParameterId["RefreshExtractDataSourcePresModel"] = "refreshExtractDatasourcePresModel"; + // DPI_RefreshExtractDataSourceList, having type RefreshExtractDataSourcePresModel[] + ParameterId["RefreshExtractDataSourceList"] = "refreshExtractDatasourceList"; + // DPI_ExtractHistoryPresModel, having type ExtractHistoryPresModel + ParameterId["ExtractHistoryPresModel"] = "extractHistoryPresModel"; + // DPI_ExtractHistoryItemPresModel, having type ExtractHistoryItemPresModel + ParameterId["ExtractHistoryItemPresModel"] = "extractHistoryItem"; + // DPI_ExtractHistoryList, having type ExtractHistoryItemPresModel[] + ParameterId["ExtractHistoryList"] = "extractHistoryList"; + // DPI_DataProviderPresModel, having type DataProviderPresModel + ParameterId["DataProviderPresModel"] = "dataProviderPresModel"; + // DPI_FormatItem, having type FormatItemPresModel + ParameterId["FormatItem"] = "formatItem"; + // DPI_FormatItemList, having type FormatItemPresModel[] + ParameterId["FormatItemList"] = "formatItemList"; + // DPI_FormatContainer, having type FormatContainerPresModel + ParameterId["FormatContainer"] = "formatContainer"; + // DPI_FormatPane, having type FormatPanePresModel + ParameterId["FormatPane"] = "formatPane"; + // DPI_FormatSection, having type FormatSectionPresModel + ParameterId["FormatSection"] = "formatSection"; + // DPI_CollapsibleSection, having type CollapsibleSectionPresModel + ParameterId["CollapsibleSection"] = "collapsibleSection"; + // DPI_CompositeContainer, having type CompositeContainerPresModel + ParameterId["CompositeContainer"] = "compositeContainer"; + // DPI_UnitContainer, having type UnitContainerPresModel + ParameterId["UnitContainer"] = "unitContainer"; + // DPI_TabGroup, having type TabGroupPresModel + ParameterId["TabGroup"] = "tabGroup"; + // DPI_Tab, having type TabPresModel + ParameterId["Tab"] = "tab"; + // DPI_FormatControl, having type FormatControlPresModel + ParameterId["FormatControl"] = "formatControl"; + // DPI_TextControl, having type TextControlPresModel + ParameterId["TextControl"] = "textControl"; + // DPI_NumericControl, having type NumericControlPresModel + ParameterId["NumericControl"] = "numericControl"; + // DPI_ColorControl, having type ColorControlPresModel + ParameterId["ColorControl"] = "colorControl"; + // DPI_ToggleControl, having type ToggleControlPresModel + ParameterId["ToggleControl"] = "toggleControl"; + // DPI_SelectorControl, having type SelectorControlPresModel + ParameterId["SelectorControl"] = "enumStringStyle"; + // DPI_StatsAnalyticSpec, having type StatsAnalyticSpecPresModel + ParameterId["StatsAnalyticSpec"] = "statsAnalyticSpec"; + // DPI_ClusterSpec, having type ClusterSpecPresModel + ParameterId["ClusterSpec"] = "clusteringSpec"; + // DPI_ClusterResults, having type ClusterResultsPresModel + ParameterId["ClusterResults"] = "clusterResults"; + // DPI_ClusterUnit, having type ClusterUnitPresModel + ParameterId["ClusterUnit"] = "cluster"; + // DPI_ClusterUnits, having type ClusterUnitPresModel[] + ParameterId["ClusterUnits"] = "clusterUnitPresModels"; + // DPI_ClusterFieldANOVA, having type ClusterFieldANOVAPresModel + ParameterId["ClusterFieldANOVA"] = "clusterFieldAnova"; + // DPI_ClusterFieldANOVATable, having type ClusterFieldANOVAPresModel[] + ParameterId["ClusterFieldANOVATable"] = "clusterFieldAnovaTablePresModel"; + // DPI_ClusterEdit, having type ClusterEditPresModel + ParameterId["ClusterEdit"] = "clusterEditPresModel"; + // DPI_ClusterDescription, having type ClusterDescribePresModel + ParameterId["ClusterDescription"] = "clusterDescription"; + // DPI_OutlierResults, having type OutlierResultsPresModel + ParameterId["OutlierResults"] = "outlierResults"; + // DPI_ConnectToDataServerSourceResult, having type ConnectToDataServerSourceResultPresModel + ParameterId["ConnectToDataServerSourceResult"] = "connectToDataServerSourceResult"; + // DPI_DataServerConnectionReturnStatus, having type ConnectToDataServerSourceResultPresModel + ParameterId["DataServerConnectionReturnStatus"] = "dataServerConnectionReturnStatus"; + // DPI_WebQuantitativeColorDialog, having type WebQuantitativeColorDialogPresModel + ParameterId["WebQuantitativeColorDialog"] = "quantitativeColorDialog"; + // DPI_WebCategoricalColorDialog, having type WebCategoricalColorDialogPresModel + ParameterId["WebCategoricalColorDialog"] = "categoricalColorDialog"; + // DPI_WebSaveDatasourceDialog, having type WebSaveDatasourceDialogPresModel + ParameterId["WebSaveDatasourceDialog"] = "saveDatasourceDialog"; + // DPI_BorderStyleSpec, having type StyleSpecPresModel + ParameterId["BorderStyleSpec"] = "borderStyleSpec"; + // DPI_HaloStyleSpec, having type StyleSpecPresModel + ParameterId["HaloStyleSpec"] = "haloStyleSpec"; + // DPI_MarksColorUberEffects, having type MarksColorUberEffectsPresModel + ParameterId["MarksColorUberEffects"] = "marksColorUberEffects"; + // DPI_CategoricalColorEncoding, having type CategoricalColorEncodingPresModel + ParameterId["CategoricalColorEncoding"] = "categoricalColorEncoding"; + // DPI_CategoricalShapeEncoding, having type CategoricalShapeEncodingPresModel + ParameterId["CategoricalShapeEncoding"] = "categoricalShapeEncoding"; + // DPI_ShapePalettePresModel, having type ShapePalettePresModel + ParameterId["ShapePalettePresModel"] = "shapePalettePresModel"; + // DPI_ShapePalettePresModels, having type ShapePalettePresModel[] + ParameterId["ShapePalettePresModels"] = "shapePalettePresModels"; + // DPI_DataSourceDateProperties, having type DataSourceDatePropertiesPresModel + ParameterId["DataSourceDateProperties"] = "datasourceDateProperties"; + // DPI_DatePropertiesDateFormat, having type DatePropertiesDateFormatPresModel + ParameterId["DatePropertiesDateFormat"] = "datePropertiesDateFormat"; + // DPI_DatePropertiesDateFormats, having type DatePropertiesDateFormatPresModel[] + ParameterId["DatePropertiesDateFormats"] = "datePropertiesDateFormats"; + // DPI_HierarchySelect, having type HierarchySelectModel + ParameterId["HierarchySelect"] = "hierarchySelect"; + // DPI_HierarchySelectMember, having type HierarchySelectMemberPresModel + ParameterId["HierarchySelectMember"] = "hierarchySelectMember"; + // DPI_HierarchySelectMemberList, having type HierarchySelectMemberPresModel[] + ParameterId["HierarchySelectMemberList"] = "hierarchySelectMemberList"; + // DPI_HierarchySetDefaultMember, having type HierarchySetDefaultMemberPresModel + ParameterId["HierarchySetDefaultMember"] = "hierarchySetDefaultMember"; + // DPI_SemiStructSchema, having type SemiStructSchemaPresModel + ParameterId["SemiStructSchema"] = "semiStructSchema"; + // DPI_SemiStructSchemaMember, having type SemiStructSchemaMemberPresModel + ParameterId["SemiStructSchemaMember"] = "semiStructSchemaMember"; + // DPI_SemiStructSchemaMemberList, having type SemiStructSchemaMemberPresModel[] + ParameterId["SemiStructSchemaMemberList"] = "semiStructSchemaMemberList"; + // DPI_ParameterEditInfo, having type ParameterEditInfoPresModel + ParameterId["ParameterEditInfo"] = "parameterEditInfo"; + // DPI_ProductParameterInfo, having type ProductParameterInfoPresModel + ParameterId["ProductParameterInfo"] = "productParameterInfo"; + // DPI_CaptionedDatasourceField, having type CaptionedDatasourceInfoPresModel + ParameterId["CaptionedDatasourceField"] = "captionedDatasourceField"; + // DPI_CaptionedDatasourceFields, having type CaptionedDatasourceInfoPresModel[] + ParameterId["CaptionedDatasourceFields"] = "captionedDatasourceFields"; + // DPI_EditedParameterRangeDomain, having type ParameterRangeDomainPresModel + ParameterId["EditedParameterRangeDomain"] = "editedParameterRangeDomain"; + // DPI_ParameterRangeDomain, having type ParameterRangeDomainPresModel + ParameterId["ParameterRangeDomain"] = "parameterRangeDomain"; + // DPI_ParameterListDomain, having type ParameterListDomainPresModel + ParameterId["ParameterListDomain"] = "parameterListDomain"; + // DPI_ParameterListDomainMember, having type ParameterListDomainMemberPresModel + ParameterId["ParameterListDomainMember"] = "parameterListDomainMember"; + // DPI_ParameterListDomainMembers, having type ParameterListDomainMemberPresModel[] + ParameterId["ParameterListDomainMembers"] = "parameterListDomainMembers"; + // DPI_IndexedDomainMember, having type IndexedDomainMemberPresModel + ParameterId["IndexedDomainMember"] = "indexedDomainMember"; + // DPI_IndexedDomainMembers, having type IndexedDomainMemberPresModel[] + ParameterId["IndexedDomainMembers"] = "indexedDomainMembers"; + // DPI_NewIndexedDomainMembers, having type IndexedDomainMemberPresModel[] + ParameterId["NewIndexedDomainMembers"] = "newIndexedDomainMembers"; + // DPI_ParameterListDomainDiff, having type parameter-list-domain-diff + ParameterId["ParameterListDomainDiff"] = "parameterListDomainDiff"; + // DPI_IndexRange, having type IndexRangePresModel + ParameterId["IndexRange"] = "indexRange"; + // DPI_IndexRanges, having type IndexRangePresModel[] + ParameterId["IndexRanges"] = "indexRanges"; + // DPI_CategoricalFind, having type CategoricalFindPresModel + ParameterId["CategoricalFind"] = "categoricalFind"; + // DPI_CaptionedDataValue, having type CaptionedDataValuePresModel + ParameterId["CaptionedDataValue"] = "captionedDataValue"; + // DPI_SelectedValueCaption, having type CaptionedDataValuePresModel + ParameterId["SelectedValueCaption"] = "selectedValueCaption"; + // DPI_DataValueCaptionList, having type CaptionedDataValuePresModel[] + ParameterId["DataValueCaptionList"] = "dataValueCatpionList"; + // DPI_RangeDataValue, having type RangeDataValuePresModel + ParameterId["RangeDataValue"] = "rangeDataValue"; + // DPI_ParameterRangeDataValue, having type RangeDataValuePresModel + ParameterId["ParameterRangeDataValue"] = "parameterRangeDataValue"; + // DPI_DataValueRangeCaptions, having type DataValueRangeCaptionsPresModel + ParameterId["DataValueRangeCaptions"] = "dataValueRangeCaptions"; + // DPI_IndependentDimension, having type IndependentDimensionPresModel + ParameterId["IndependentDimension"] = "independentDimension"; + // DPI_IndependentDimensions, having type IndependentDimensionPresModel[] + ParameterId["IndependentDimensions"] = "independentDimensions"; + // DPI_AttributePerspective, having type PerspectivePresModel + ParameterId["AttributePerspective"] = "attributePerspective"; + // DPI_CubePerspective, having type PerspectivePresModel + ParameterId["CubePerspective"] = "cubePerspective"; + // DPI_AttributePerspectives, having type PerspectivePresModel[] + ParameterId["AttributePerspectives"] = "attributePerspectives"; + // DPI_CalculatedMembersForEditingPresModel, having type EditCalculatedMembersPresModel + ParameterId["CalculatedMembersForEditingPresModel"] = "calculatedMembersForEditingPresmodel"; + // DPI_CalculatedMember, having type CalculatedMemberPresModel + ParameterId["CalculatedMember"] = "calculatedMember"; + // DPI_NewCalculatedMember, having type CalculatedMemberPresModel + ParameterId["NewCalculatedMember"] = "newCalculatedMember"; + // DPI_UpdatedCalculatedMember, having type CalculatedMemberPresModel + ParameterId["UpdatedCalculatedMember"] = "updatedCalculatedMember"; + // DPI_CalculatedMembersList, having type CalculatedMemberPresModel[] + ParameterId["CalculatedMembersList"] = "calculatedMembersList"; + // DPI_CalculatedMemberHierarchyItem, having type CalculatedMemberHierarchyItemPresModel + ParameterId["CalculatedMemberHierarchyItem"] = "calculatedMemberHierarchyItem"; + // DPI_CalculatedMemberHierarchyList, having type CalculatedMemberHierarchyItemPresModel[] + ParameterId["CalculatedMemberHierarchyList"] = "calculatedMemberHierarchyList"; + // DPI_SummaryCardPresModel, having type SummaryCardPresModel + ParameterId["SummaryCardPresModel"] = "summaryCard"; + // DPI_MeasureSummary, having type MeasureSummaryPresModel + ParameterId["MeasureSummary"] = "measureSummary"; + // DPI_MeasureSummaryList, having type MeasureSummaryPresModel[] + ParameterId["MeasureSummaryList"] = "measureSummaryList"; + // DPI_AnnotationPresModel, having type AnnotationPresModel + ParameterId["AnnotationPresModel"] = "annotation"; + // DPI_AnnotationList, having type AnnotationPresModel[] + ParameterId["AnnotationList"] = "annotationList"; + // DPI_AnnotationShapeStyle, having type AnnotationShapeStylePresModel + ParameterId["AnnotationShapeStyle"] = "annotationShapeStyle"; + // DPI_Telemetry, having type TelemetryPresModel + ParameterId["Telemetry"] = "telemetry"; + // DPI_DataSourceTelemetry, having type DataSourceTelemetryPresModel + ParameterId["DataSourceTelemetry"] = "dataSourceTelemetry"; + // DPI_DataSourceTelemetryList, having type DataSourceTelemetryPresModel[] + ParameterId["DataSourceTelemetryList"] = "dataSourceTelemetryList"; + // DPI_VisualSpecificationTelemetry, having type VisualSpecificationTelemetryPresModel + ParameterId["VisualSpecificationTelemetry"] = "visualSpecificationTelemetry"; + // DPI_VisualSpecificationTelemetryList, having type VisualSpecificationTelemetryPresModel[] + ParameterId["VisualSpecificationTelemetryList"] = "visualSpecificationTelemetryList"; + // DPI_UnderlyingDataTable, having type UnderlyingDataTablePresModel + ParameterId["UnderlyingDataTable"] = "underlyingDataTable"; + // DPI_UnderlyingDataTables, having type UnderlyingDataTablePresModel[] + ParameterId["UnderlyingDataTables"] = "underlyingDataTables"; + // DPI_UnderlyingDataTableColumn, having type UnderlyingDataTableColumnPresModel + ParameterId["UnderlyingDataTableColumn"] = "underlyingDataTableColumn"; + // DPI_UnderlyingDataTableColumns, having type UnderlyingDataTableColumnPresModel[] + ParameterId["UnderlyingDataTableColumns"] = "underlyingDataTableColumns"; + // DPI_PageCacheID, having type PageCacheIDPresModel + ParameterId["PageCacheID"] = "pageCacheId"; + // DPI_RelationalPageCacheID, having type PageCacheIDPresModel + ParameterId["RelationalPageCacheID"] = "relationalPageCacheId"; + // DPI_SearchResultsCacheID, having type PageCacheIDPresModel + ParameterId["SearchResultsCacheID"] = "searchResultsCacheId"; + // DPI_PageInfo, having type PageInfoPresModel + ParameterId["PageInfo"] = "pageInfo"; + // DPI_RowColPair, having type RowColPairPresModel + ParameterId["RowColPair"] = "rowColPair"; + // DPI_TopLeftRowCol, having type RowColPairPresModel + ParameterId["TopLeftRowCol"] = "topLeftRowCol"; + // DPI_BotRightRowCol, having type RowColPairPresModel + ParameterId["BotRightRowCol"] = "botRightRowCol"; + // DPI_RowColPairs, having type RowColPairPresModel[] + ParameterId["RowColPairs"] = "rowColPairs"; + // DPI_TableViewCacheInfo, having type TableViewCachePresModel + ParameterId["TableViewCacheInfo"] = "tableViewCacheInfo"; + // DPI_TableViewInfo, having type tableViewInfoPresModel + ParameterId["TableViewInfo"] = "tableViewInfo"; + // DPI_TableViewColumnInfo, having type TableViewColumnInfoPresModel + ParameterId["TableViewColumnInfo"] = "tableViewColumnInfo"; + // DPI_TableViewColumns, having type TableViewColumnInfoPresModel[] + ParameterId["TableViewColumns"] = "tableViewColumns"; + // DPI_TableViewPageItem, having type TableViewPageItemPresModel + ParameterId["TableViewPageItem"] = "tableViewPageItem"; + // DPI_TableViewPageColumns, having type TableViewPageItemPresModel[] + ParameterId["TableViewPageColumns"] = "tableViewPageColumns"; + // DPI_TableViewPageRow, having type TableViewPageRowPresModel + ParameterId["TableViewPageRow"] = "tableViewPageRow"; + // DPI_TableViewPageRows, having type TableViewPageRowPresModel[] + ParameterId["TableViewPageRows"] = "tableViewPageRows"; + // DPI_TableViewPage, having type TableViewPagePresModel + ParameterId["TableViewPage"] = "tableViewPage"; + // DPI_CategoricalValuePicker, having type CategoricalValuePickerPresModel + ParameterId["CategoricalValuePicker"] = "categoricalValuePicker"; + // DPI_AnnotationShapeBorderStyle, having type LineStylePresModel + ParameterId["AnnotationShapeBorderStyle"] = "annotationShapeBorderStyle"; + // DPI_AnotationShapeStrokeStyle, having type LineStylePresModel + ParameterId["AnotationShapeStrokeStyle"] = "annotationShapeStrokeStyle"; + // DPI_CategoricalBinEditorPresModel, having type CategoricalBinEditorPresModel + ParameterId["CategoricalBinEditorPresModel"] = "categoricalBinEditor"; + // DPI_CategoricalBinItem, having type CategoricalBinItemPresModel + ParameterId["CategoricalBinItem"] = "categoricalBinItemPresModel"; + // DPI_CategoricalBinItems, having type CategoricalBinItemPresModel[] + ParameterId["CategoricalBinItems"] = "categoricalBinItemPresModels"; + // DPI_MeasurePickerFieldInfo, having type MeasurePickerFieldInfoPresModel + ParameterId["MeasurePickerFieldInfo"] = "measurePickerFieldInfo"; + // DPI_MeasurePickerFields, having type MeasurePickerFieldInfoPresModel[] + ParameterId["MeasurePickerFields"] = "measurePickerFields"; + // DPI_MeasureAggregationInfo, having type MeasureAggregationInfoPresModel + ParameterId["MeasureAggregationInfo"] = "measureAggregationInfo"; + // DPI_MeasureAggregations, having type MeasureAggregationInfoPresModel[] + ParameterId["MeasureAggregations"] = "measureAggregations"; + // DPI_TuplePair, having type TuplePairPresModel + ParameterId["TuplePair"] = "tuplePair"; + // DPI_DimensionBound, having type DimensionBoundPresModel + ParameterId["DimensionBound"] = "dimensionBound"; + // DPI_PerspectiveBounds, having type DimensionBoundPresModel[] + ParameterId["PerspectiveBounds"] = "perspectiveBounds"; + // DPI_FilterPerspectiveInfoPresModel, having type FilterPerspectiveInfoPresModel + ParameterId["FilterPerspectiveInfoPresModel"] = "filterPerspectiveInfo"; + // DPI_TableRelevance, having type TableRelevancePresModel + ParameterId["TableRelevance"] = "tableRelevance"; + // DPI_AddInRegistrationPresModel, having type AddInRegistrationPresModel + ParameterId["AddInRegistrationPresModel"] = "addInRegistrationPresModel"; + // DPI_AddInRegistrationPresModelList, having type AddInRegistrationPresModel[] + ParameterId["AddInRegistrationPresModelList"] = "addInRegistrationPresModelList"; + // DPI_AddInDashboardAuthoringWidget, having type AddInDashboardWidgetPresModel + ParameterId["AddInDashboardAuthoringWidget"] = "addInDashboardAuthoringWidgetPresModel"; + // DPI_AddInInstance, having type AddInInstancePresModel + ParameterId["AddInInstance"] = "addInInstancePresModel"; + // DPI_AddInLocator, having type AddInLocatorPresModel + ParameterId["AddInLocator"] = "addInLocatorPresModel"; + // DPI_AddInContext, having type AddInContext + ParameterId["AddInContext"] = "addInContext"; + // DPI_AddInMode, having type AddInMode + ParameterId["AddInMode"] = "addInMode"; + // DPI_SetAxisDataValueResult, having type SetAxisDataValueResult + ParameterId["SetAxisDataValueResult"] = "setAxisDataValueResult"; + // DPI_AxisExtentStartType, having type AxisExtentType + ParameterId["AxisExtentStartType"] = "axisExtentStartType"; + // DPI_AxisExtentEndType, having type AxisExtentType + ParameterId["AxisExtentEndType"] = "axisExtentEndType"; + // DPI_AxisExtentsType, having type AxisExtentType + ParameterId["AxisExtentsType"] = "axisExtentsType"; + // DPI_AddInEnvironment, having type AddInEnvironmentPresModel + ParameterId["AddInEnvironment"] = "addInEnvironmentPresModel"; + // DPI_AddInDashboardInfo, having type AddInDashboardInfoPresModel + ParameterId["AddInDashboardInfo"] = "addInDashboardInfoPresModel"; + // DPI_AddInSettingsInfo, having type AddInSettingsInfoPresModel + ParameterId["AddInSettingsInfo"] = "addInSettingsInfo"; + // DPI_AddInBootstrapInfo, having type AddInBootstrapInfoPresModel + ParameterId["AddInBootstrapInfo"] = "addInBootstrapInfo"; + // DPI_AddInDebugSettings, having type AddInDebugSettingsPresModel + ParameterId["AddInDebugSettings"] = "addInDebugSettings"; + // DPI_RichText, having type RichTextPresModel + ParameterId["RichText"] = "richText"; + // DPI_RichTextKeywordSubList, having type RichTextKeywordSubListPresModel + ParameterId["RichTextKeywordSubList"] = "richTextKeywordsSublist"; + // DPI_RichTextKeywordSubLists, having type RichTextKeywordSubListPresModel[] + ParameterId["RichTextKeywordSubLists"] = "richTextKeywordSublists"; + // DPI_RichTextKeywordList, having type RichTextKeywordListPresModel + ParameterId["RichTextKeywordList"] = "richTextKeywordsList"; + // DPI_RichTextBlockStyle, having type RichTextBlockStylePresModel + ParameterId["RichTextBlockStyle"] = "richTextBlockStyle"; + // DPI_RichTextContentStyle, having type RichTextContentStylePresModel + ParameterId["RichTextContentStyle"] = "richTextContentStyle"; + })(ParameterId = exports.ParameterId || (exports.ParameterId = {})); + + +/***/ }, +/* 82 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var CommandIds_1 = __webpack_require__(83); + var Params_1 = __webpack_require__(81); + var CommandMappingRegistry_1 = __webpack_require__(84); + var CommandRegistration_1 = __webpack_require__(85); + var CommandMappingRegistryFactory = (function () { + function CommandMappingRegistryFactory() { + } + /** + * Creates and populates a new CommandMappingRegistry for the specific version number requested + * + * @static + * @param {VersionNumber} versionNumber + * @param {boolean} runningInDesktop + * @returns {CommandMappingRegistry} + * @memberof CommandMappingRegistryFactory + */ + CommandMappingRegistryFactory.createCommandMappingRegistry = function (versionNumber, runningInDesktop) { + var result = new CommandMappingRegistry_1.CommandMappingRegistry(); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.InitializeExtension, CommandIds_1.DocCommands.InitializeAddInInstance, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ExtensionLocator, Params_1.ParameterId.AddInLocator)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ExtensionBootstrapInfo, Params_1.ParameterId.AddInBootstrapInfo))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetUnderlyingData, CommandIds_1.DocCommands.GetUnderlyingData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IgnoreAliases, Params_1.ParameterId.IgnoreAliases), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IgnoreSelection, Params_1.ParameterId.IgnoreSelection), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IncludeAllColumns, Params_1.ParameterId.IncludeAllColumns), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.MaxRows, Params_1.ParameterId.MaxRows), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.UnderlyingDataTable, Params_1.ParameterId.UnderlyingDataTable))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetDataSummaryData, CommandIds_1.DocCommands.GetSummaryData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IgnoreAliases, Params_1.ParameterId.IgnoreAliases), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IgnoreSelection, Params_1.ParameterId.IgnoreSelection), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.UnderlyingSummaryDataTable, Params_1.ParameterId.UnderlyingDataTable))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetDataSourceData, CommandIds_1.DocCommands.GetDataSourceData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSourceId, Params_1.ParameterId.Datasource), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IgnoreAliases, Params_1.ParameterId.IgnoreAliases), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.MaxRows, Params_1.ParameterId.MaxRows), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ColumnsToInclude, Params_1.ParameterId.FieldDisplayNames)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSourceDataTable, Params_1.ParameterId.UnderlyingDataTable))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.ApplyCategoricalFilter, CommandIds_1.DocCommands.CategoricalFilter, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.QualifiedFieldCaption), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FilterValues, Params_1.ParameterId.FilterAliases), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FilterUpdateType, Params_1.ParameterId.FilterUpdateType), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.IsExcludeMode, Params_1.ParameterId.Exclude, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Worksheet), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Dashboard)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.FieldCaption))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.ApplyRangeFilter, CommandIds_1.DocCommands.RangeFilter, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.QualifiedFieldCaption), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FilterRangeMin, Params_1.ParameterId.RangeMin, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FilterRangeMax, Params_1.ParameterId.RangeMax, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FilterRangeNullOption, Params_1.ParameterId.Included, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Worksheet), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Dashboard)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.FieldCaption))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.ClearFilter, CommandIds_1.DocCommands.ResetFilter, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.QualifiedFieldCaption), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Worksheet), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.Dashboard)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldName, Params_1.ParameterId.FieldCaption))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetSelectedMarks, CommandIds_1.DocCommands.GetSelectionData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.SelectedData, Params_1.ParameterId.SelectionData))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetHighlightedMarks, CommandIds_1.DocCommands.GetHighlightedData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.HighlightedData, Params_1.ParameterId.HighlightedData))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.SaveExtensionSettings, CommandIds_1.DocCommands.SaveAddInSettings, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ExtensionLocator, Params_1.ParameterId.AddInLocator), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.SettingsValues, Params_1.ParameterId.AddInSettings)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ExtensionSettingsInfo, Params_1.ParameterId.AddInSettingsInfo))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetParametersForSheet, CommandIds_1.DocCommands.GetParameterModels, [], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterInfos, Params_1.ParameterId.ParameterCtrls))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.FindParameter, CommandIds_1.DocCommands.FindParameterModel, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterCaption, Params_1.ParameterId.FieldCaption, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterFieldName, Params_1.ParameterId.FieldNameString, true)], + // We might not get a response if the parameter isn't found + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterInfo, Params_1.ParameterId.ParameterCtrl, true))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.ChangeParameterValue, CommandIds_1.DocCommands.SetParameterValue, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterFieldName, Params_1.ParameterId.GlobalFieldName), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterValue, Params_1.ParameterId.ValueStr)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ParameterInfo, Params_1.ParameterId.ParameterCtrl))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.ClearSelectedMarks, CommandIds_1.DocCommands.ClearSelectedMarks, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)])); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.SelectByValue, CommandIds_1.DocCommands.SelectByValue, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.Selection, Params_1.ParameterId.Selection, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.SelectionUpdateType, Params_1.ParameterId.SelectionUpdateType), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.HierValSelectionModels, Params_1.ParameterId.HierValSelectionModels, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DimValSelectionModels, Params_1.ParameterId.DimValSelectionModels, true), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.QuantRangeSelectionModels, Params_1.ParameterId.QuantRangeSelectionModels, true)])); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetDataSources, CommandIds_1.DocCommands.GetSchema, [], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSchema, Params_1.ParameterId.DataSchema))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.RefreshDataSource, (runningInDesktop) ? CommandIds_1.UICommands.RefreshDataSourceUI : CommandIds_1.SrvCommands.RefreshData, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSourceId, Params_1.ParameterId.Datasource)], undefined, (runningInDesktop) ? CommandRegistration_1.CommandNamespace.TabUI : CommandRegistration_1.CommandNamespace.TabSrv)); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetFilters, CommandIds_1.DocCommands.GetWorksheetFilters, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.WorksheetFilters, Params_1.ParameterId.FiltersInfo))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetCategoricalDomain, CommandIds_1.DocCommands.GetCategoricalDomain, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldId, Params_1.ParameterId.FieldName), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DomainType, Params_1.ParameterId.FilterDomainType)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.CategoricalDomain, Params_1.ParameterId.CategoricalDomain))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetRangeDomain, CommandIds_1.DocCommands.GetQuantitativeDomain, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.VisualId, Params_1.ParameterId.VisualIDPM), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.FieldId, Params_1.ParameterId.FieldName), + new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DomainType, Params_1.ParameterId.FilterDomainType)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.QuantitativeDomain, Params_1.ParameterId.QuantitativeDomain))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetJoinDescription, CommandIds_1.DocCommands.GetJoinDescriptionPresModel, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSourceId, Params_1.ParameterId.Datasource)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.JoinDescription, Params_1.ParameterId.JoinDescription))); + result.addCommand(new CommandRegistration_1.CommandRegistration(api_internal_contract_1.VerbId.GetConnectionDescriptionSummaries, CommandIds_1.DocCommands.GetConnectionDescriptionSummaryPresModels, [new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.DataSourceId, Params_1.ParameterId.Datasource)], new CommandRegistration_1.CommandParameter(api_internal_contract_1.ParameterId.ConnectionDescriptionSummaries, Params_1.ParameterId.ConnectionDescriptionSummaries))); + return result; + }; + return CommandMappingRegistryFactory; + }()); + exports.CommandMappingRegistryFactory = CommandMappingRegistryFactory; + + +/***/ }, +/* 83 */ +/***/ function(module, exports) { + + "use strict"; + /* tslint:disable */ + // ----------------------------------------------------------------------------- + // + // This file is the copyrighted property of Tableau Software and is protected + // by registered patents and other applicable U.S. and international laws and + // regulations. + // + // Unlicensed use of the contents of this file is prohibited. Please refer to + // the NOTICES.txt file for further details. + // + // ----------------------------------------------------------------------------- + // WARNING: Computer generated file. Do not hand modify. + // DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/commands-enum-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-cmd-wrappers.data'] + Object.defineProperty(exports, "__esModule", { value: true }); + var DocCommands; + (function (DocCommands) { + // Saves the settings for the specified add-in id + DocCommands["SaveAddInSettings"] = "save-add-in-settings"; + // Gets the pres model for an add-in instance. + DocCommands["GetAddInInstancePresModel"] = "get-add-in-instance-pres-model"; + // Gets the pres model for the dashboard authoring widget for add-ins. + DocCommands["GetAddInDashboardAuthoringWidgetPresModel"] = "get-add-in-dashboard-authoring-widget-pres-model"; + // Gets the necessary information for an add-in to initialize itself. + DocCommands["InitializeAddInInstance"] = "initialize-add-in-instance"; + // Enables or disable javascript debugging of an add-in. + DocCommands["SetAddInJsDebuggingEnabled"] = "set-add-in-js-debugging-enabled"; + // Whether or not we should pause before loading. If missing, toggle the value + DocCommands["SetPauseBeforeLoadingAddIn"] = "set-pause-before-loading-add-in"; + // Reloads the Add-In widget and web page. + DocCommands["ReloadAddIn"] = "reload-add-in"; + // Retrieves the context menu for a dashboard add-in. + DocCommands["GetAddInZoneContextMenu"] = "get-add-in-zone-context-menu"; + // Gets the pres model which indicates what the debug settings for add-ins is. + DocCommands["GetAddInDebugSettingsPresModel"] = "get-add-in-debug-settings-pres-model"; + // Primary use is for building context menus + DocCommands["IsSelectionAnEditableParameter"] = "is-selection-an-editable-parameter"; + // Check if selection can be used as base for creating a new parameter. Primary use is for building context menus + DocCommands["GetCreateParameterState"] = "get-create-parameter-state"; + // Uses EditParameter to get and return info about the presmodel without maintaining the controller + DocCommands["GetParameterEditInfo"] = "get-parameter-edit-info"; + // Initialize the controller and its stored parameter then return a populated presmodel + DocCommands["CreateParameter"] = "create-parameter"; + // Same underlying logic as CreateParameter but edits rather than creating a new parameter + DocCommands["EditParameter_New"] = "edit-parameter-new"; + // Add a member of a parameter domain. Changes are applied to intermediate state and saved on commit + DocCommands["AddParameterMember"] = "add-parameter-member"; + // Edit a member of a parameter domain. Changes are applied to intermediate state and saved on commit + DocCommands["EditParameterMember"] = "edit-parameter-member"; + // Delete a series of ranges of members from the parameter list. + DocCommands["DeleteParameterMembers"] = "delete-parameter-members"; + // Copy a series of ranges of members of a parameter list + DocCommands["CopyParameterMembers"] = "copy-parameter-members"; + // Move a series of ranges of members of a parameter list + DocCommands["MoveParameterMembers"] = "move-parameter-members"; + // Change domain of a parameter. Changes are applied to intermediate state and saved on commit + DocCommands["EditParameterDomainType"] = "edit-parameter-domain-type"; + // Change datatype of a parameter. Changes are applied to intermediate state and saved on commit + DocCommands["EditParameterDataType"] = "edit-parameter-data-type"; + // Change display format of a parameter. Changes are applied to intermediate state and saved on commit + DocCommands["EditParameterFormat"] = "edit-parameter-format"; + // Validate changes to a parameter's range domain and apply to intermediate state. Changes are saved on commit + DocCommands["EditParameterRange"] = "edit-parameter-range"; + // Edit the value of a non-list domain parameter + DocCommands["EditParameterValue"] = "edit-parameter-value"; + // Edit the value of a list domain parameter + DocCommands["EditParameterValueIndex"] = "edit-parameter-value-index"; + // Update the parameter caption and description - used to keep backend in sync. No verification/return is requried. + DocCommands["EditParameterDisplayInfo"] = "edit-parameter-display-info"; + // Update the domain of the parameter using a field (column or parameter) as a base + DocCommands["UpdateParameterFromField"] = "update-parameter-from-field"; + // Update the list domain of a parameter from a plain text representation of values + DocCommands["ParseParameterListDomain"] = "parse-parameter-list-domain"; + // Clears the parameter's domain of all members + DocCommands["ClearParameterListDomain"] = "clear-parameter-list-domain"; + // Creates or edits parameter from intermediate state. Takes a few properties that are cached in dialog and applies them pre-commit. + DocCommands["CommitParameterEdits"] = "commit-parameter-edits"; + // Gets the model for a particular parameter or returns an empty response if one is not found. + DocCommands["FindParameterModel"] = "find-parameter-model"; + // Gets the pres model for the show data dialog + DocCommands["GetShowDataPresModel"] = "get-show-data-pres-model"; + // Export underlying data from the ShowDataDialog to a CSV file + DocCommands["ShowDataExportToCSV"] = "show-data-export-to-csv"; + // Gets the summary data for a worksheet + DocCommands["GetSummaryData"] = "get-summary-data"; + // Gets the underlying data for a worksheet + DocCommands["GetUnderlyingData"] = "get-underlying-data"; + // Gets the underlying data for a specific data source. + DocCommands["GetDataSourceData"] = "get-data-source-data"; + // Select all marks that have the tuple's value for the given field . + DocCommands["SelectByTupleValue"] = "select-by-tuple-value"; + // Clear all the selected marks for the given worksheet + DocCommands["ClearSelectedMarks"] = "clear-selected-marks"; + // Creates or updates and existing filter based on the provided updates. + DocCommands["ApplyCategoricalFilterUpdates"] = "apply-categorical-filter-updates"; + // Search filter domain for text and return any matching tuples. + DocCommands["CategoricalFilterSearch"] = "categorical-filter-search"; + // Clear all members from the table of the identified cache. + DocCommands["CategoricalFilterClearRelationalCache"] = "categorical-filter-clear-relational-cache"; + // Create tuples for an existing filter from supplied text. + DocCommands["GetCategoricalFilterTuplesFromText"] = "get-categorical-filter-tuples-from-text"; + // Returns a presmodel backing a categorical filter, initializing a data cache for fast lookup of the filter's member domain. + DocCommands["GetCategoricalFilter"] = "get-categorical-filter"; + // Retrieves a page of data to display in the filter's list domain + DocCommands["GetCategoricalFilterDomainPage"] = "get-categorical-filter-domain-page"; + // Reset filter to committed state + DocCommands["ResetCategoricalFilterDeferred"] = "reset-categorical-filter-deferred"; + // Use uncommitted state to reset the filter's controller + DocCommands["RecreateCategoricalFilterController"] = "recreate-categorical-filter-controller"; + // Validates a Categroical Filter name. + DocCommands["ValidateCategoricalFilterName"] = "validate-categorical-filter-name"; + // Retrieves the field aggregations allowed for the field being filtered. + DocCommands["GetFilterFieldAggregations"] = "get-filter-field-aggregations"; + // Gets a summary of the filter pattern. + DocCommands["GetCategoricalFilterPatternSummary"] = "get-categorical-filter-pattern-summary"; + // Gets a summery of the filter condition. + DocCommands["GetCategoricalFilterConditionSummary"] = "get-categorical-filter-condition-summary"; + // Load the current minimum and maximum data value range for the condition field. + DocCommands["LoadCategoricalFilterConditionFieldValueRange"] = "load-categorical-filter-condition-field-value-range"; + // Validates a Categorical Filter's condition formula and re-writes it. + DocCommands["ValidateCategoricalFilterConditionFormula"] = "validate-categorical-filter-condition-formula"; + // Gets a summery of the filter limit. + DocCommands["GetCategoricalFilterLimitSummary"] = "get-categorical-filter-limit-summary"; + // Validates a Categorical Filter's limit count. + DocCommands["ValidateCategoricalFilterLimitCount"] = "validate-categorical-filter-limit-count"; + // Validates a Categorical Filter's limit formula, and re-writes the formula. + DocCommands["ValidateCategoricalFilterLimitFormula"] = "validate-categorical-filter-limit-formula"; + // Validates a Categorical Filter's limit. + DocCommands["ValidateCategoricalFilterLimit"] = "validate-categorical-filter-limit"; + // Inform cache when a user changes the range + DocCommands["CategoricalFilterSetRangeTypeDeferred"] = "categorical-filter-set-range-type-deferred"; + // Inform cache when a user changes whether the selection is exclusive + DocCommands["CategoricalFilterSetSelectionExclusiveDeferred"] = "categorical-filter-set-selection-exclusive-deferred"; + // Inform cache when a user changes whether an empty selection should be considered a selection of 'All' in a Manual selection mode + DocCommands["CategoricalFilterSetUseAllWhenManualIsEmptyDeferred"] = "categorical-filter-set-use-all-when-manual-is-empty-deferred"; + // Inform cache when a user alters the preset type + DocCommands["CategoricalFilterSetPresetTypeDeferred"] = "categorical-filter-set-preset-type-deferred"; + // Inform cache the user has selected one or more members + DocCommands["CategoricalFilterSelectRelationalMembersDeferred"] = "categorical-filter-select-relational-members-deferred"; + // Inform cache the user has deselected one or more members + DocCommands["CategoricalFilterDeselectRelationalMembersDeferred"] = "categorical-filter-deselect-relational-members-deferred"; + // Inform cache when a user selects everything in the domain + DocCommands["CategoricalFilterSelectAllRelationalMembersDeferred"] = "categorical-filter-select-all-relational-members-deferred"; + // Inform cache when a user deselects everything in the domain + DocCommands["CategoricalFilterDeselectAllRelationalMembersDeferred"] = "categorical-filter-deselect-all-relational-members-deferred"; + // Inform cache the user wants to see a different domain (e.g. relevant values only) + DocCommands["CategoricalFilterSetDomainTypeDeferred"] = "categorical-filter-set-domain-type-deferred"; + // Set whether filters apply to totals as well as non-totals table calcs + DocCommands["FilterApplyToTotalTableCalcs"] = "filter-apply-to-total-table-calcs"; + // Gets the list of filters used in a worksheet + DocCommands["GetWorksheetFilters"] = "get-worksheet-filters"; + // Gets the domain for a categorical Filter + DocCommands["GetCategoricalDomain"] = "get-categorical-domain"; + // Gets the domain for a quantitative Filter + DocCommands["GetQuantitativeDomain"] = "get-quantitative-domain"; + // Creates a datasource filter store and returns a list of the current datasource filters. + DocCommands["CreateDatasourceFilterStore"] = "create-datasource-filter-store"; + // Commits the pending datasource filter changes in the filter store. + DocCommands["CommitDatasourceFilterStore"] = "commit-datasource-filter-store"; + // Gets the list of datasource fields that can be filtered. + DocCommands["GetDatasourceFilterFieldPickerModel"] = "get-datasource-filter-field-picker-model"; + // Get field information needed for creating a datasource filter. + DocCommands["GetDatasourceFilterFieldInfo"] = "get-datasource-filter-field-info"; + // Gets a filter presentation model form a filter store. + DocCommands["GetFilterFromStore"] = "get-filter-from-store"; + // Removes a filter from a filter store. + DocCommands["RemoveFilterFromStore"] = "remove-filter-from-store"; + // Releases a filter store, and its resources, once it is no longer needed. + DocCommands["ReleaseFilterStore"] = "release-filter-store"; + // + DocCommands["GetHighlightedData"] = "get-highlighted-data"; + // + DocCommands["GetSelectionData"] = "get-selection"; + // + DocCommands["Select"] = "select"; + // + DocCommands["SelectAll"] = "select-all"; + // + DocCommands["SelectByValue"] = "select-by-value"; + // + DocCommands["SelectNoneIncludingMaster"] = "select-none-including-master"; + // + DocCommands["AddManualItemsToFilter"] = "add-manual-items-to-filter"; + // + DocCommands["CategoricalFilter"] = "categorical-filter"; + // + DocCommands["CategoricalFilterByIndex"] = "categorical-filter-by-index"; + // + DocCommands["ChangeSharedFilter"] = "change-shared-filter"; + // + DocCommands["ClearContextFilters"] = "clear-context-filters"; + // + DocCommands["ClearExistingFilter"] = "clear-existing-filter"; + // + DocCommands["DefaultFilter"] = "default-filter"; + // + DocCommands["FilterGeo"] = "filter-geo"; + // + DocCommands["FilterNeg"] = "filter-neg"; + // + DocCommands["FilterNulls"] = "filter-nulls"; + // + DocCommands["FilterTargets"] = "filter-targets"; + // + DocCommands["GetSharedFilterPresModel"] = "get-shared-filter-pres-model"; + // + DocCommands["HierarchicalFilter"] = "hierarchical-filter"; + // + DocCommands["KeepOnlyOrExclude"] = "keep-only-or-exclude"; + // + DocCommands["RangeFilter"] = "range-filter"; + // + DocCommands["RelDateFilter"] = "relative-date-filter"; + // + DocCommands["ResetFilter"] = "reset-filter"; + // + DocCommands["ShowGeoAtDefault"] = "show-geo-at-default"; + // + DocCommands["ShowSVAtDefault"] = "show-sv-at-default"; + // + DocCommands["ToggleLockQuickFilters"] = "toggle-lock-quick-filters"; + // + DocCommands["AddDataConnection"] = "add-data-connection"; + // + DocCommands["AddDrillPath"] = "add-drill-path"; + // + DocCommands["AddCredentialsFromKeychain"] = "add-credentials-from-keychain"; + // + DocCommands["AddCredentialsFromKeychainFile"] = "add-credentials-from-keychain-file"; + // + DocCommands["AddFieldFolder"] = "add-field-folder"; + // + DocCommands["AddSubtotals"] = "add-subtotals"; + // + DocCommands["AddToDrillPath"] = "add-to-drill-path"; + // + DocCommands["AddToFieldFolder"] = "add-to-field-folder"; + // + DocCommands["AggregateMeasuresFlag"] = "aggregate-measures"; + // + DocCommands["ApplyCalculation"] = "apply-calculation"; + // + DocCommands["ApplyPageSetupOptions"] = "apply-page-setup-options"; + // + DocCommands["ApplyTableOptions"] = "apply-table-options"; + // + DocCommands["ApplyTypeInPill"] = "apply-type-in-pill"; + // + DocCommands["Assert"] = "assert"; + // + DocCommands["AttemptConnectDataSourcesOnSheet"] = "attempt-connect-datasources-on-sheet"; + // + DocCommands["AttemptConnectWorkbook"] = "attempt-connect-workbook"; + // + DocCommands["AttemptDataSourcesConnection"] = "attempt-datasources-connection"; + // + DocCommands["AutoUpdates"] = "auto-update"; + // + DocCommands["Brush"] = "highlight"; + // + DocCommands["BrushSpecial"] = "highlight-special"; + // + DocCommands["BuildDataSchemaDataSourceContextMenu"] = "build-data-schema-data-source-context-menu"; + // + DocCommands["BuildDataSchemaContextMenu"] = "build-data-schema-context-menu"; + // + DocCommands["BuildDataSchemaFieldContextMenu"] = "build-data-schema-field-context-menu"; + // + DocCommands["BuildDataSchemaDrillPathContextMenu"] = "build-data-schema-drill-path-context-menu"; + // + DocCommands["BuildFileTableInfoPresModel"] = "build-file-table-info-pres-model"; + // + DocCommands["BuildSheetTabContextMenu"] = "build-sheet-tab-context-menu"; + // + DocCommands["CancelDataSourcePresModel"] = "cancel-datasource-pres-model"; + // + DocCommands["CatBinMergeSplitLabel"] = "categorical-bin-merge-split"; + // + DocCommands["CategoricalQuickFilterEdit"] = "categorical-quick-filter-edit"; + // + DocCommands["CategoricalQuickFilterExcludeValues"] = "categorical-quick-filter-exclude-values"; + // + DocCommands["CategoricalQuickFilterIncludeAllWhenEmpty"] = "categorical-quick-filter-include-all-when-empty"; + // + DocCommands["CategoricalQuickFilterMode"] = "categorical-quick-filter-mode"; + // + DocCommands["CategoricalQuickFilterPattern"] = "categorical-quick-filter-pattern"; + // + DocCommands["ChangeAggregation"] = "change-aggregation"; + // + DocCommands["ChangeAlphaLevel"] = "change-alpha-level"; + // + DocCommands["ChangeBorder"] = "change-border"; + // + DocCommands["ChangeFieldType"] = "change-field-type"; + // + DocCommands["ChangeForecastColumnType"] = "change-forecast-column-type"; + // + DocCommands["ChangeHalo"] = "change-halo"; + // + DocCommands["ChangeMarkers"] = "change-markers"; + // + DocCommands["ChangeSize"] = "change-size"; + // + DocCommands["ChangeSheetTabColor"] = "change-sheet-tab-color"; + // + DocCommands["ClearAllAxisRanges"] = "clear-axis-ranges"; + // + DocCommands["ClearCalcModel"] = "clear-calculation-model"; + // + DocCommands["ClearFilters"] = "clear-filters"; + // + DocCommands["ClearFormatting"] = "clear-formatting"; + // + DocCommands["ClearFuture"] = "clear-future"; + // + DocCommands["ClearLayout"] = "clear-layout"; + // + DocCommands["ClearQuickFilter"] = "clear-quick-filter"; + // + DocCommands["ClearSorts"] = "clear-sorts"; + // + DocCommands["CloseConnection"] = "close-connection"; + // + DocCommands["CloseDataSource"] = "close-data-source"; + // + DocCommands["ConnectionAddGoogleAnalyticsDimension"] = "connection-add-google-analytics-dimension"; + // + DocCommands["ConnectionAddGoogleAnalyticsMeasure"] = "connection-add-google-analytics-measure"; + // + DocCommands["ConnectionAddNewTable"] = "connection-add-new-table"; + // + DocCommands["ConnectionAddCoalesce"] = "connection-add-coalesce"; + // + DocCommands["ConnectionAddPivot"] = "connection-add-pivot"; + // + DocCommands["ConnectionConvertToUnionAndEdit"] = "connection-convert-to-union-and-edit"; + // + DocCommands["ConnectionConvertToUnion"] = "connection-convert-to-union"; + // + DocCommands["ConnectionEditUnion"] = "connection-edit-union"; + // + DocCommands["ConnectionAddOrEditBatchUnion"] = "connection-add-or-edit-batch-union"; + // + DocCommands["ConnectionChangeTableProperty"] = "connection-change-table-property"; + // + DocCommands["ConnectionCountEntity"] = "connection-count-entity"; + // + DocCommands["ConnectionDataServerFetchMoreDatasources"] = "connection-dataserver-fetch-more-datasources"; + // + DocCommands["ConnectionDataServerProjectSelect"] = "connection-dataserver-change-selected-project"; + // + DocCommands["ConnectionDataServerUpdateFetchParameters"] = "connection-dataserver-update-fetch-parameters"; + // + DocCommands["ConnectionDataServerFlushCache"] = "connection-dataserver-flush-cache"; + // + DocCommands["ConnectionDeleteAllTables"] = "connection-delete-all-tables"; + // + DocCommands["ConnectionDeleteTable"] = "connection-delete-table"; + // + DocCommands["ConnectionEditGoogleAnalyticsAccount"] = "connection-edit-google-analytics-account"; + // + DocCommands["ConnectionEditGoogleAnalyticsDateRange"] = "connection-edit-google-analytics-date-range"; + // + DocCommands["ConnectionEditGoogleAnalyticsMeasureGroup"] = "connection-edit-google-analytics-measure-group"; + // + DocCommands["ConnectionToggleGAQueryPartitioning"] = "connection-toggle-ga-query-partitioning"; + // + DocCommands["ConnectionEditGoogleAnalyticsProperty"] = "connection-edit-google-analytics-property"; + // + DocCommands["ConnectionEditGoogleAnalyticsView"] = "connection-edit-google-analytics-view"; + // + DocCommands["ConnectionEditGoogleAnalyticsSegment"] = "connection-edit-google-analytics-segment"; + // + DocCommands["ConnectionEditJoinClauses"] = "connection-edit-join-clauses"; + // + DocCommands["ConnectionEditJoinType"] = "connection-edit-join-type"; + // + DocCommands["ConnectionEditSQLText"] = "connection-edit-sql-text"; + // + DocCommands["ConnectionFetchEntity"] = "connection-fetch-entity"; + // + DocCommands["ConnectionSetForceExtractRefresh"] = "connection-set-force-extract-refresh"; + // + DocCommands["ConnectionPrepareDataSourceForEdit"] = "connection-prepare-datasource-for-edit"; + // + DocCommands["ConnectionClearRefreshAttributes"] = "connection-clear-refresh-attributes"; + // + DocCommands["ConnectionRemoveGoogleAnalyticsDimension"] = "connection-remove-google-analytics-dimension"; + // + DocCommands["ConnectionRemoveGoogleAnalyticsMeasure"] = "connection-remove-google-analytics-measure"; + // + DocCommands["ConnectionRemoveCoalesce"] = "connection-remove-coalesce"; + // + DocCommands["ConnectionRemovePivot"] = "connection-remove-pivot"; + // + DocCommands["ConnectionAddDateParseFormats"] = "connection-add-date-parse-formats"; + // + DocCommands["ConnectionRenameTable"] = "connection-rename-table"; + // + DocCommands["ConnectionReplaceRelationWithSQLText"] = "connection-replace-relation-with-sql-text"; + // + DocCommands["ConnectionReplaceTable"] = "connection-replace-table"; + // + DocCommands["ConnectionResetTableAlias"] = "connection-reset-table-alias"; + // + DocCommands["ConnectionSelectCatalog"] = "connection-select-catalog"; + // + DocCommands["ConnectionSelectCube"] = "connection-select-cube"; + // + DocCommands["ConnectionSelectStoredProcedure"] = "connection-select-stored-procedure"; + // + DocCommands["ConnectionSelectBigQueryLegacySQLCheckBox"] = "connection-select-bigquery-legacy-check"; + // + DocCommands["ConnectionToggleHasHeaderRow"] = "connection-toggle-has-header-row"; + // + DocCommands["ConnectionToggleTableCleaning"] = "connection-toggle-table-cleaning"; + // + DocCommands["ConnectionToggleUseExtract"] = "connection-toggle-use-extract"; + // + DocCommands["ConnectionViewTableCleaningResults"] = "connection-view-table-cleaning-results"; + // + DocCommands["ConnectToDataServerSource"] = "connect-data-server-datasource"; + // + DocCommands["ConsiderZerosEmptyFlag"] = "consider-zeros-empty"; + // + DocCommands["ConvertUnnamedFields"] = "convert-unnamed-fields"; + // + DocCommands["Crash"] = "crash"; + // + DocCommands["CreateAggregateRole"] = "create-aggregate-role"; + // + DocCommands["CreateConnection"] = "create-connection"; + // + DocCommands["CreateDefaultQuickFilter"] = "create-default-quick-filter"; + // + DocCommands["CreateTypeInPill"] = "create-type-in-pill"; + // + DocCommands["CustomDataGridFieldOrder"] = "custom-datagrid-field-order"; + // + DocCommands["CustomDateAggregation"] = "custom-date-aggregation"; + // + DocCommands["CustomSplitField"] = "custom-split-field"; + // + DocCommands["DebugAssertion"] = "debug-assertion"; + // + DocCommands["DecrementParameterValue"] = "decr-parameter-value"; + // + DocCommands["DeleteFields"] = "delete-calculation-fields-command"; + // + DocCommands["DeleteSheet"] = "delete-sheet"; + // + DocCommands["DescribeDrillPath"] = "describe-drill-path"; + // + DocCommands["DescribeSortFilter"] = "describe-sort-filter"; + // + DocCommands["DismissNullWart"] = "dismiss-null-wart"; + // + DocCommands["DomainQuickFilter"] = "domain-quick-filter"; + // + DocCommands["DoubleFreeCrash"] = "double-free"; + // + DocCommands["DropNowhere"] = "drop-nowhere"; + // + DocCommands["DropOnSchemaViewer"] = "drop-on-schema-viewer"; + // + DocCommands["DropOnShelf"] = "drop-on-shelf"; + // + DocCommands["DropOnCalcEditor"] = "drop-on-calc-editor"; + // + DocCommands["DropOnShowMe"] = "drop-on-showme"; + // + DocCommands["DropPrepare"] = "drop-prepare"; + // + DocCommands["DualAxis"] = "dual-axis"; + // + DocCommands["DuplicateSheet"] = "duplicate-sheet"; + // + DocCommands["EditCopyCalc"] = "edit-copy-calc"; + // + DocCommands["EditDropLines"] = "edit-drop-lines"; + // + DocCommands["EditEnumeratedGroup"] = "edit-enumerated-group"; + // + DocCommands["EditNestedGroup"] = "edit-nested-group"; + // + DocCommands["EditPill"] = "edit-pill"; + // + DocCommands["EditPrimitiveType"] = "edit-primitive-type"; + // + DocCommands["EnableAllBrushing"] = "enable-all-highlights"; + // + DocCommands["EnableQuickFilter"] = "enable-quick-filter"; + // + DocCommands["EnableSheetBrushing"] = "enable-sheet-highlights"; + // + DocCommands["EnableThemedBrushing"] = "enable-themed-highlights"; + // + DocCommands["EnumerateVariables"] = "enumerate-variables"; + // + DocCommands["EnumerateVariableSelectionValues"] = "enumerate-variable-selection-values"; + // + DocCommands["EstablishConnection"] = "establish-connection"; + // + DocCommands["EstablishMatchingConnections"] = "establish-matching-connections"; + // + DocCommands["ExportDataToText"] = "export-data-to-text"; + // + DocCommands["ExtSvcConfig"] = "ext-svc-config"; + // + DocCommands["ExtSvcConfigConnect"] = "ext-svc-config-connect"; + // + DocCommands["Extract"] = "extract"; + // + DocCommands["SetDataGridCurrentTable"] = "set-data-grid-current-table"; + // + DocCommands["FetchTableRelevance"] = "fetch-table-relevance"; + // + DocCommands["FetchCachedTableRelevance"] = "fetch-cached-table-relevance"; + // + DocCommands["FlipLabels"] = "flip-labels"; + // + DocCommands["FloatingToolbar"] = "zoom-controls"; + // + DocCommands["FloatingToolbarToggle"] = "zoom-controls-toggle"; + // + DocCommands["ForecastConfig"] = "forecast-config"; + // + DocCommands["ForecastToggle"] = "forecast-toggle"; + // + DocCommands["FormatWorkbook"] = "format-workbook"; + // + DocCommands["GeographicSearchQuery"] = "geographic-search-query"; + // + DocCommands["GeographicSearchLoadData"] = "geographic-search-load-data"; + // + DocCommands["GeographicSearchIsDataDoneLoading"] = "geographic-search-data-done-loading"; + // + DocCommands["GeographicSearchToggleVisibility"] = "geographic-search-toggle-visibility"; + // + DocCommands["GetEditConnectionPresModel"] = "get-edit-connection-pres-model"; + // + DocCommands["GetEditEnumeratedGroupPresModel"] = "get-edit-enumerated-group-pres-model"; + // + DocCommands["GetEditNestedGroupPresModel"] = "get-edit-nested-group-pres-model"; + // + DocCommands["GetFrameFinderPresModel"] = "get-frame-finder-pres-model"; + // + DocCommands["GetGoogleSheetsListPresModel"] = "get-google-sheets-list-pres-model"; + // + DocCommands["GetGoogleSheetPanePresModel"] = "get-google-sheet-pane-pres-model"; + // + DocCommands["GetInitialSQLPresModel"] = "get-initial-sql-pres-model"; + // + DocCommands["GetQueryBandingPresModel"] = "get-query-banding-pres-model"; + // + DocCommands["GetTabbedAuthenticationPresModel"] = "get-tabbed-authentication-pres-model"; + // + DocCommands["GetActiveSheet"] = "get-active-sheet"; + // + DocCommands["GetAlphaLevel"] = "get-alpha-level"; + // + DocCommands["GetAppConfig"] = "get-app-config"; + // + DocCommands["GetDisabledSecondaryDSFields"] = "get-disabled-secondaryds-fields"; + // + DocCommands["GetBlendingFields"] = "get-blending-fields"; + // + DocCommands["GetCalculationPresModel"] = "get-calculation-pres-model"; + // + DocCommands["GetCategoricalColor"] = "get-categorical-color"; + // + DocCommands["GetClientInfo"] = "get-client-info"; + // + DocCommands["GetCommands"] = "get-commands"; + // + DocCommands["GetConnectionDescriptionPresModel"] = "get-connection-description-pres-model"; + // + DocCommands["GetDSDropdownPresModel"] = "get-ds-dropdown-pres-model"; + // + DocCommands["GetDataPreviewWindowMessagePresModel"] = "get-data-preview-window-pres-model"; + // + DocCommands["GetDataSourcePresModel"] = "get-datasource-pres-model"; + // + DocCommands["GetDataSourceSortPresModel"] = "get-datasource-sort-pres-model"; + // + DocCommands["GetDataSourcePropertiesPresModel"] = "get-datasource-properties-pres-model"; + // + DocCommands["GetConnectionSettingsPresModel"] = "get-connection-settings-pres-model"; + // + DocCommands["GetDashboard"] = "get-dashboard"; + // + DocCommands["GetDataPreview"] = "get-data-preview"; + // + DocCommands["GetDatabaseEnumerationPresModel"] = "get-database-enumeration-pres-model"; + // + DocCommands["GetDefaultColor"] = "get-default-color"; + // + DocCommands["GetDefaultShape"] = "get-default-shape"; + // + DocCommands["GetDragPresModelForText"] = "get-drag-pres-model-for-text"; + // + DocCommands["GetDropTargetPresModel"] = "get-drop-target-pres-model"; + // + DocCommands["GetEditDataServerConnectionPresModel"] = "get-edit-data-server-connection-pres-model"; + // + DocCommands["GetEditDropLinesModel"] = "get-edit-drop-lines-model"; + // + DocCommands["GetEncodingState"] = "get-encoding-state"; + // + DocCommands["GetEncodingTypeMenuModel"] = "get-encoding-type-menu"; + // + DocCommands["GetExtSvcConfig"] = "get-ext-svc-config"; + // + DocCommands["GetForecastPresModel"] = "get-forecast-pres-model"; + // + DocCommands["GetJoinDescriptionPresModel"] = "get-join-description-pres-model"; + // + DocCommands["GetQuickFilter"] = "get-quick-filter"; + // + DocCommands["GetQuickFilters"] = "get-quick-filters"; + // + DocCommands["GetReferenceLinePresModel"] = "get-reference-line-pres-model"; + // + DocCommands["GetParameters"] = "get-parameters"; + // + DocCommands["GetParameterModels"] = "get-parameter-models"; + // + DocCommands["GetParametersRegistryInfo"] = "get-params-registry-info"; + // + DocCommands["GetPivotPresModel"] = "get-pivot-pres-model"; + // + DocCommands["GetScene"] = "get-scene"; + // + DocCommands["GetSchemaEnumerationPresModel"] = "get-schema-enumeration-pres-model"; + // + DocCommands["GetSheetsInfo"] = "get-sheets-info"; + // + DocCommands["GetShowMe"] = "get-show-me"; + // + DocCommands["GetStandardConnectionEnumerationPresModel"] = "get-standard-connection-enumeration-pres-model"; + // + DocCommands["GetStoredProcedureEnumerationPresModel"] = "get-stored-procedure-enumeration-pres-model"; + // + DocCommands["GetStoredProcedureParametersPresModel"] = "get-stored-procedure-parameters-pres-model"; + // + DocCommands["GetTableEnumerationPresModel"] = "get-table-enumeration-pres-model"; + // + DocCommands["GetTableCleaningPresModel"] = "get-table-cleaning-pres-model"; + // + DocCommands["GetTargetFieldList"] = "get-target-field-list"; + // + DocCommands["GetTopLevelConnectionDescriptionPresModel"] = "get-top-level-connection-description-pres-model"; + // + DocCommands["GetTypeInPillPresModel"] = "get-type-in-pill-pres-model"; + // + DocCommands["GetUberTipPresModel"] = "get-ubertip-pres-model"; + // + DocCommands["GetUnionInfoPresModel"] = "get-union-info-pres-model"; + // + DocCommands["GetVisual"] = "get-visual"; + // + DocCommands["GetVizData"] = "get-viz-data"; + // + DocCommands["GetWarehouseEnumerationPresModel"] = "get-warehouse-enumeration-pres-model"; + // + DocCommands["GetWorkbook"] = "get-workbook"; + // + DocCommands["GetWorldUpdate"] = "get-world-update"; + // + DocCommands["GoToSheet"] = "goto-sheet"; + // + DocCommands["HeapCorruptionCrash"] = "corrupt-heap"; + // + DocCommands["HideColumnFieldLabel"] = "hide-column-field-label"; + // + DocCommands["HideEmptyColsFlag"] = "hide-empty-cols"; + // + DocCommands["HideEmptyRowsFlag"] = "hide-empty-rows"; + // + DocCommands["HideLabel"] = "hide-label"; + // + DocCommands["HideRowFieldLabel"] = "hide-row-field-label"; + // + DocCommands["HierarchicalQuickFilterUpdateSetFunction"] = "hierarchical-quick-filter-update-set-function"; + // + DocCommands["IncludeInTooltip"] = "include-in-tooltip"; + // + DocCommands["IncludeOtherCategoricalBin"] = "include-other-cat-bin"; + // + DocCommands["IncrementExtract"] = "increment-extract"; + // + DocCommands["IncrementParameterValue"] = "incr-parameter-value"; + // + DocCommands["CreateCalc"] = "create-calc"; + // + DocCommands["EditCalc"] = "edit-calc"; + // + DocCommands["InvokeHyperlink"] = "invoke-hyperlink"; + // + DocCommands["KeepOnlyOrExcludeSelection"] = "keep-only-or-exclude-selection"; + // + DocCommands["LabelDrill"] = "label-drill"; + // + DocCommands["LabelDrillCtx"] = "label-drill-ctx"; + // + DocCommands["LevelDrill"] = "level-drill"; + // + DocCommands["LoadUrl"] = "load-url"; + // + DocCommands["ListPublishedDataSources"] = "list-published-datasources"; + // + DocCommands["MarkLabel"] = "mark-label"; + // + DocCommands["MarkTrail"] = "mark-trail"; + // + DocCommands["MemoryDumpObjectCounts"] = "memory-dump-object-counts"; + // + DocCommands["MemoryLeak"] = "memory-leak"; + // + DocCommands["Merge"] = "merge-or-split"; + // + DocCommands["MigrateDataSource"] = "migrate-data-source"; + // + DocCommands["ModifyMarksInSet"] = "add-or-remove-marks"; + // + DocCommands["MoveAreaAnnotationText"] = "move-area-annotation-text"; + // + DocCommands["MoveColumnTotals"] = "move-column-totals"; + // + DocCommands["MoveMark"] = "move-mark"; + // + DocCommands["MovePointAnnotation"] = "move-point-annotation"; + // + DocCommands["MovePointAnnotationTarget"] = "move-point-annotation-target"; + // + DocCommands["MoveReferenceLine"] = "move-reference-line"; + // + DocCommands["MoveRowTotals"] = "move-row-totals"; + // + DocCommands["NavigateToSheet"] = "navigate-to-sheet"; + // + DocCommands["PostCalcJoinClauseResult"] = "post-calc-join-clause-result"; + // + DocCommands["NewDocDashboard"] = "new-dashboard"; + // + DocCommands["NewDocWorksheet"] = "new-worksheet"; + // + DocCommands["NonRangedRemoveReferenceLine"] = "non-ranged-remove-reference-line"; + // + DocCommands["OptimizeExtract"] = "optimize-extract"; + // + DocCommands["OptOutActions"] = "opt-out-actions"; + // + DocCommands["PageHistorySettings"] = "page-history-settings"; + // + DocCommands["PageToggleTrails"] = "page-toggle-trails"; + // + DocCommands["ParseUIName"] = "parse-ui-name"; + // + DocCommands["Percentages"] = "percentages"; + // + DocCommands["Perspectives"] = "perspectives"; + // + DocCommands["PositionPointAnnotation"] = "position-point-annotation"; + // + DocCommands["ProtocolPoolLog"] = "protocol-pool-log"; + // + DocCommands["PublishToWorkgroup"] = "publish-to-workgroup"; + // + DocCommands["PublishDataSource"] = "publish-datasource"; + // + DocCommands["PublishDataSourceFromData"] = "publish-data-source-from-data"; + // + DocCommands["PublishDataSourceFromWorkbookData"] = "publish-data-source-from-workbook-data"; + // + DocCommands["QuantitativeQuickFilterEdit"] = "quantitative-quick-filter-edit"; + // + DocCommands["QuantitativeModeQuickFilter"] = "quantitative-mode-quick-filter"; + // + DocCommands["QueryMigrateDataSources"] = "query-migrate-data-sources"; + // + DocCommands["QuickSort"] = "quick-sort"; + // + DocCommands["RangedByIndexMerge"] = "ranged-by-index-merge"; + // + DocCommands["RangedByValueMerge"] = "ranged-by-value-merge"; + // + DocCommands["Record"] = "record"; + // + DocCommands["Redo"] = "redo"; + // + DocCommands["RefreshExtract"] = "refresh-extract"; + // + DocCommands["RefreshFromSource"] = "refresh-from-source"; + // + DocCommands["RelativeDateQuickFilterEdit"] = "relative-date-quick-filter-edit"; + // + DocCommands["RemoveAllReferenceLines"] = "remove-all-reference-lines"; + // + DocCommands["RemoveDrillPath"] = "remove-drill-path"; + // + DocCommands["RemoveExtract"] = "remove-extract"; + // + DocCommands["RemoveFieldFolder"] = "remove-field-folder"; + // + DocCommands["RemoveFieldLabel"] = "remove-field-label"; + // + DocCommands["RemoveFields"] = "remove-fields"; + // + DocCommands["RemoveFieldsFromShelf"] = "remove-fields-from-shelf"; + // + DocCommands["RemoveFromDrillPath"] = "remove-from-drill-path"; + // + DocCommands["RemoveFromFieldFolder"] = "remove-from-field-folder"; + // + DocCommands["RemoveReferenceLine"] = "remove-reference-line"; + // + DocCommands["RemoveSubtotals"] = "remove-subtotals"; + // + DocCommands["RenameDataSource"] = "rename-data-source"; + // + DocCommands["RenameDrillPath"] = "rename-drill-path"; + // + DocCommands["RenameFieldFolder"] = "rename-field-folder"; + // + DocCommands["RenameSheet"] = "rename-sheet"; + // + DocCommands["ReorderLabels"] = "reorder-labels"; + // + DocCommands["ReportBug"] = "report-bug"; + // + DocCommands["RequestDataSourcePresModel"] = "request-datasource-pres-model"; + // + DocCommands["ResetParameterCtrlTitle"] = "reset-parameter-ctrl-title"; + // + DocCommands["ResetTooltip"] = "reset-tooltip"; + // + DocCommands["ResizeAreaAnnotationText"] = "resize-area-annotation-text"; + // + DocCommands["ResizeAxis"] = "resize-axis"; + // + DocCommands["ResizeCell"] = "resize-cell"; + // + DocCommands["ResizeHeader"] = "resize-header"; + // + DocCommands["ResizePointAnnotation"] = "resize-point-annotation"; + // + DocCommands["Revert"] = "revert"; + // + DocCommands["RotateFieldLabel"] = "rotate-field-label"; + // + DocCommands["RotateLabel"] = "rotate-label"; + // + DocCommands["SplitFieldLabel"] = "split-field-label"; + // + DocCommands["RunAction"] = "run-action"; + // + DocCommands["RunScript"] = "run-script"; + // + DocCommands["RunUpdates"] = "run-update"; + // + DocCommands["SaveModel"] = "save-model"; + // + DocCommands["SavePublishedDStoFile"] = "save-published-ds-to-file"; + // + DocCommands["SelectDataSource"] = "select-data-source"; + // + DocCommands["SelectFieldsInShelf"] = "select-fields-in-shelf"; + // + DocCommands["SendDataConnectionTableViewMessage"] = "send-data-connection-tableview-message"; + // + DocCommands["SetActiveDataSourceName"] = "set-active-data-source-name"; + // + DocCommands["SetActiveConnectionName"] = "set-active-connection-name"; + // + DocCommands["SetActiveDataSource"] = "set-active-datasource"; + // + DocCommands["SetBasePalette"] = "set-base-palette"; + // + DocCommands["SetCategoricalColor"] = "set-categorical-color"; + // + DocCommands["SetDataCacheDelta"] = "set-data-cache-delta"; + // + DocCommands["SetDataPreviewAutoUpdate"] = "set-data-preview-auto-update"; + // + DocCommands["SetDataPreviewCustomFieldOrder"] = "set-data-preview-custom-field-order"; + // + DocCommands["SetDefaultColor"] = "set-default-color"; + // + DocCommands["SetDefaultShape"] = "set-default-shape"; + // + DocCommands["SetFilterContext"] = "set-filter-context"; + // + DocCommands["SetFilterShared"] = "set-filter-shared"; + // + DocCommands["SetInitialSQL"] = "set-initial-sql"; + // + DocCommands["SetItemColor"] = "set-item-color"; + // + DocCommands["SetItemColorResetCustomization"] = "set-item-color-reset-customization"; + // + DocCommands["SetItemEncodingType"] = "set-item-encoding-type"; + // + DocCommands["SetMarkSize"] = "set-mark-size"; + // + DocCommands["SetPageNavFlag"] = "set-page-flag"; + // + DocCommands["SetParameterCtrlDisplayFlags"] = "set-parameter-ctrl-display-flags"; + // + DocCommands["SetParameterCtrlDisplayMode"] = "set-parameter-ctrl-display-mode"; + // + DocCommands["SetParameterCtrlTitle"] = "set-parameter-ctrl-title"; + // + DocCommands["SetParameterValue"] = "set-parameter-value"; + // + DocCommands["SetPrimitive"] = "set-primitive"; + // + DocCommands["SetQueryBanding"] = "set-query-banding"; + // + DocCommands["SetQuickFilterIncludedValues"] = "set-quick-filter-included"; + // + DocCommands["SetReferenceLineFormula"] = "set-reference-line-formula"; + // + DocCommands["SetReferenceLineConstantValue"] = "set-reference-line-constant-value"; + // + DocCommands["SetSheetFormatting"] = "set-sheet-formatting"; + // + DocCommands["SetSheetSize"] = "set-sheet-size"; + // + DocCommands["SetTotalsType"] = "set-totals-type"; + // + DocCommands["SetWorkbookLocale"] = "set-workbook-locale"; + // + DocCommands["ShowCatCtrlQuickFilter"] = "show-cat-ctrl-quick-filter"; + // + DocCommands["ShowColFieldNamesFlag"] = "show-col-field-names"; + // + DocCommands["ShowColTotalsFlag"] = "show-col-totals"; + // + DocCommands["ShowColumnFieldLabel"] = "show-column-field-label"; + // + DocCommands["ShowEmptyColsFlag"] = "show-empty-cols"; + // + DocCommands["ShowEmptyRowsFlag"] = "show-empty-rows"; + // + DocCommands["ShowForecastEditor"] = "show-forecast-editor"; + // + DocCommands["ShowFullRange"] = "show-full-range"; + // + DocCommands["ShowHeader"] = "show-header"; + // + DocCommands["ShowHiddenData"] = "show-hidden-data"; + // + DocCommands["ShowMe"] = "show-me"; + // + DocCommands["ShowQuantCtrlQuickFilter"] = "show-quant-ctrl-quick-filter"; + // + DocCommands["ShowQuickFilterDoc"] = "show-quickfilter-doc"; + // + DocCommands["ShowReferenceLineEditor"] = "show-reference-line-editor"; + // + DocCommands["ShowReferenceLineConstantValueEditor"] = "show-reference-line-constant-value-editor"; + // + DocCommands["ShowReferenceLineFormatter"] = "show-reference-line-formatter"; + // + DocCommands["ShowRowFieldLabel"] = "show-row-field-label"; + // + DocCommands["ShowRowFieldNamesFlag"] = "show-row-field-names"; + // + DocCommands["ShowRowTotalsFlag"] = "show-row-totals"; + // + DocCommands["SimpleCommandList"] = "simple-command-list"; + // + DocCommands["Sleep"] = "sleep"; + // + DocCommands["SleepBackgroundThread"] = "sleep-background-thread"; + // + DocCommands["SortDataGridByColumn"] = "sort-datagrid-by-column"; + // + DocCommands["SortDataGridFields"] = "sort-datagrid-fields"; + // + DocCommands["SpecialValues"] = "special-values"; + // + DocCommands["SplitField"] = "split-field"; + // + DocCommands["StackMarks"] = "stack-marks"; + // + DocCommands["StackOverflowCrash"] = "stack-overflow"; + // + DocCommands["SubtotalAggregation"] = "subtotal-aggregation"; + // + DocCommands["Subtotals"] = "subtotals"; + // + DocCommands["SwapFields"] = "swap-fields"; + // + DocCommands["SwapRowsAndColumns"] = "swap-rows-and-columns"; + // + DocCommands["TableauException"] = "tableau-exception"; + // + DocCommands["ToggleDropLines"] = "toggle-drop-lines"; + // + DocCommands["ToggleFieldBlending"] = "toggle-field-blending"; + // + DocCommands["ToggleMarkLabels"] = "toggle-mark-labels"; + // + DocCommands["TogglePageTitle"] = "toggle-page-title"; + // + DocCommands["ToggleParameterCtrlDisplayFlag"] = "toggle-parameter-ctrl-display-flag"; + // + DocCommands["ToggleParameterCtrlTitle"] = "toggle-parameter-ctrl-title"; + // + DocCommands["ToggleQuickFilterTitle"] = "toggle-quick-filter-title"; + // + DocCommands["ToggleVizNavigationSetting"] = "toggle-viz-navigation-setting"; + // + DocCommands["Undo"] = "undo"; + // + DocCommands["UnhideData"] = "unhide-data"; + // + DocCommands["UnhideLabel"] = "unhide-label"; + // + DocCommands["UpdateAreaAnnotation"] = "update-area-annotation"; + // + DocCommands["UpdateCalcScopeIsolation"] = "update-scope-isolation-for-calculation"; + // + DocCommands["UpdateDataServerConnectionInfo"] = "update-data-server-connection-info"; + // + DocCommands["UpdatePointAnnotationPullback"] = "update-point-annotation-pullback"; + // + DocCommands["UpdateTableCalcInfo"] = "update-table-calc-infomation"; + // + DocCommands["UpgradeExtract"] = "upgrade-extract"; + // + DocCommands["UseExtract"] = "use-extract"; + // + DocCommands["ValidateDrillPathName"] = "validate-drill-path-name"; + // + DocCommands["ValidateFormula"] = "validate-formula"; + // + DocCommands["ValidateInitialSQL"] = "validate-initial-sql"; + // + DocCommands["ValidateQueryBanding"] = "validate-query-banding"; + // + DocCommands["ValidateTypeInPill"] = "validate-type-in-pill"; + // + DocCommands["ViewParameterCtrls"] = "view-param-ctrls"; + // + DocCommands["ViewQuickFilters"] = "view-quick-filters"; + // + DocCommands["GetSchema"] = "get-schema"; + // + DocCommands["GetSchemaViewerDataSchema"] = "get-schema-viewer-data-schema"; + // + DocCommands["ConvertToDimension"] = "convert-to-dimension"; + // + DocCommands["ConvertToMeasure"] = "convert-to-measure"; + // + DocCommands["ConvertToContinuous"] = "convert-to-continuous"; + // + DocCommands["ConvertToDiscrete"] = "convert-to-discrete"; + // + DocCommands["RenameField"] = "rename-field"; + // + DocCommands["HideField"] = "hide-field"; + // + DocCommands["UnhideField"] = "unhide-field"; + // + DocCommands["HideUnusedFields"] = "hide-unused-fields"; + // + DocCommands["DuplicateFields"] = "duplicate-fields"; + // + DocCommands["CleanValues"] = "clean-values"; + // + DocCommands["ParseDate"] = "parse-date"; + // + DocCommands["MakeDate"] = "make-date"; + // + DocCommands["SetQualifyNames"] = "set-qualify-names"; + // + DocCommands["CreateMeasureFromColumn"] = "create-measure-from-column"; + // + DocCommands["RemoveFromSchemaDrillPath"] = "remove-from-schema-drill-path"; + // + DocCommands["AddToSchemaDrillPath"] = "add-to-schema-drill-path"; + // + DocCommands["RemoveSchemaDrillPath"] = "remove-schema-drill-path"; + // + DocCommands["ShowHiddenFields"] = "show-hidden-fields"; + // + DocCommands["ShowAliases"] = "show-aliases"; + // + DocCommands["SetRowDisplayCount"] = "set-row-display-count"; + // + DocCommands["ShowStructure"] = "show-structure"; + // + DocCommands["GroupByTable"] = "group-by-table"; + // + DocCommands["ChangeDataType"] = "change-data-type"; + // + DocCommands["ChangePivotStrategy"] = "change-pivot-strategy"; + // + DocCommands["ChangeDisplayAlias"] = "change-display-alias"; + // + DocCommands["SetIncludeSharedMembers"] = "set-include-shared-members"; + // + DocCommands["SetUtilityDimension"] = "set-utility-dimension"; + // + DocCommands["SetDefaultHierarchy"] = "set-default-hierarchy"; + // + DocCommands["DataSourceSortOrder"] = "data-source-sort-order"; + // + DocCommands["ClearUtilityDimension"] = "clear-utility-dimension"; + // + DocCommands["ClearDefaultSort"] = "clear-default-sort"; + // + DocCommands["SetDefaultAggregation"] = "set-default-aggregation"; + // + DocCommands["SetDefaultVTAggregation"] = "set-default-vtaggregation"; + // + DocCommands["ChangeFiscalYear"] = "change-fiscal-year"; + // + DocCommands["ChangeSemanticRole"] = "change-semantic-role"; + // + DocCommands["AddToSheet"] = "add-to-sheet"; + // + DocCommands["DropSchemaSelOnShelf"] = "drop-schema-sel-on-shelf"; + // + DocCommands["AddToSchemaFieldFolder"] = "add-to-schema-field-folder"; + // + DocCommands["RemoveFromSchemaFieldFolder"] = "remove-from-schema-field-folder"; + // + DocCommands["RemoveSchemaFieldFolder"] = "remove-schema-field-folder"; + // + DocCommands["DefaultTextFormat"] = "default-text-format"; + // + DocCommands["EditSchemaCaption"] = "edit-schema-caption"; + // + DocCommands["ResetSchemaCaption"] = "reset-schema-caption"; + // + DocCommands["CreateOutlierSet"] = "create-outlier-set"; + })(DocCommands = exports.DocCommands || (exports.DocCommands = {})); + var UICommands; + (function (UICommands) { + // + UICommands["About"] = "about"; + // + UICommands["AddDataServerDataSourceUI"] = "add-data-server-datasource-ui"; + // + UICommands["SwitchToDocumentAndAddDataServerDataSourceUI"] = "switch-to-document-and-add-data-server-ds-ui"; + // + UICommands["AddDrillPathUI"] = "add-drillpath-ui"; + // + UICommands["AddFieldFolderUI"] = "add-field-folder-ui"; + // + UICommands["AddFileToExtractUI"] = "add-file-to-extract-ui"; + // + UICommands["AddDataSourceToExtractUI"] = "add-data-source-to-extract-ui"; + // + UICommands["AddQCToSheetUI"] = "add-qc-to-sheet-ui"; + // + UICommands["AddReferenceLineUI"] = "add-reference-line-ui"; + // + UICommands["AddSchemaFieldFolderUI"] = "add-to-schema-field-folder-ui"; + // + UICommands["AddTableauServerDSConnectionUI"] = "add-tableau-server-ds-connection-ui"; + // + UICommands["AddToSchemaDrillPathUI"] = "add-to-schema-drillpath-ui"; + // + UICommands["AddToSheetUI"] = "add-to-sheet-ui"; + // + UICommands["AnnotateUI"] = "annotate-ui"; + // + UICommands["AppendDataSourceToRemoteExtractUI"] = "append-data-source-to-remote-extract-ui"; + // + UICommands["AttemptConnectDataSourcesOnSheetUI"] = "attempt-connect-datasources-on-sheet-ui"; + // + UICommands["AttemptDataSourceConnectionUI"] = "attempt-datasource-connect-ui"; + // + UICommands["AutoHideSheet"] = "auto-hide-sheet"; + // + UICommands["AutomationClickMRUItem"] = "click-mru-item"; + // + UICommands["CalculatedMembersUI"] = "calculated-members-ui"; + // + UICommands["ChangeAggregationUI"] = "change-aggregation-ui"; + // + UICommands["ChangeDataServerLogonUI"] = "change-data-server-logon-ui"; + // + UICommands["ChangeEssbaseAliasFile"] = "change-essbase-alias-file"; + // + UICommands["ChangeFieldTypeUI"] = "change-field-type-ui"; + // + UICommands["ChangeTabColorSheet"] = "change-tab-color-sheet"; + // + UICommands["CheckForProductUpdates"] = "check-for-product-updates"; + // + UICommands["ClearDashboardUI"] = "clear-dashboard-ui"; + // + UICommands["ClearSheetUI"] = "clear-sheet-ui"; + // + UICommands["ClearStoryUI"] = "clear-story-ui"; + // + UICommands["ClearVizUI"] = "clear-viz-ui"; + // + UICommands["CloseCalculationUI"] = "close-calculation-ui"; + // + UICommands["CloseDataSourceUI"] = "close-datasource-ui"; + // + UICommands["CloseWorkbook"] = "close-workbook"; + // + UICommands["ColorLegendEditUI"] = "color-legend-edit-ui"; + // + UICommands["CommitPillEditUI"] = "commit-pill-edit-ui"; + // + UICommands["ConnectDataSourceUI"] = "connect-datasource-ui"; + // + UICommands["ConnectRepromptUI"] = "connect-reprompt-ui"; + // + UICommands["ConnectVariablePromptUI"] = "connect-variable-prompt-ui"; + // + UICommands["ConnectVariablePromptMatchingUI"] = "connect-variable-prompt-matching-ui"; + // + UICommands["ConnectionAddNewCustomSQLUI"] = "connection-add-new-custom-sql-ui"; + // + UICommands["ConnectionAddNewTableUI"] = "connection-add-new-table-ui"; + // + UICommands["ConnectionDataGridCopyUI"] = "connection-data-grid-copy-ui"; + // + UICommands["ConnectionEditCustomSQLUI"] = "connection-custom-sql-ui"; + // + UICommands["ConnectionEditExtractUI"] = "connection-extract-ui"; + // + UICommands["ConnectionEditDBVariablesUI"] = "connection-edit-db-variables-ui"; + // + UICommands["ConnectionEditConnectionUI"] = "connection-edit-connection-ui"; + // + UICommands["ConnectionFinalizeDataSourceUI"] = "connection-finalize-datasource-ui"; + // + UICommands["ConnectionFinalizeExtractStatesUI"] = "connection-finalize-extract-states-ui"; + // + UICommands["ConnectionGetTypeGroupPresModelUI"] = "connection-get-type-group-pres-model-ui"; + // + UICommands["ConnectionGetSavedDataSourcesPresModelUI"] = "connection-get-saved-ds-pres-model-ui"; + // + UICommands["ConnectionPartitioningFailureUI"] = "connection-partitioning-failure-ui"; + // + UICommands["ConnectionReplaceTableUI"] = "connection-replace-table-ui"; + // + UICommands["ConnectionSearchCatalogUI"] = "connection-search-catalog-ui"; + // + UICommands["ConnectionSearchCubeUI"] = "connection-search-cube-ui"; + // + UICommands["ConnectionSelectCatalogUI"] = "connection-select-catalog-ui"; + // + UICommands["ConnectionSelectCubeUI"] = "connection-select-cube-ui"; + // + UICommands["ConnectionSelectStandardConnectionUI"] = "connection-select-standard-connection-ui"; + // + UICommands["ConnectionSelectStoredProcedureUI"] = "connection-select-stored-procedure-ui"; + // + UICommands["ConnectionShowEditTableDialogUI"] = "connection-show-edit-table-ui"; + // + UICommands["ConnectionShowPivotDialogUI"] = "conneciton-show-pivot-dialog-ui"; + // + UICommands["ConnectionSortCatalogUI"] = "connection-sort-catalog-ui"; + // + UICommands["ConnectionSortCubeUI"] = "connection-sort-cube-ui"; + // + UICommands["ConnectionValidateCustomSQLUI"] = "connection-validate-custom-sql-ui"; + // + UICommands["ConnectToCloudFile"] = "connect-to-cloud-file"; + // + UICommands["ConnectToDataServerSourceUI"] = "connect-data-server-datasource-ui"; + // + UICommands["ConnectionConvertToSQLUI"] = "connection-convert-to-sql-ui"; + // + UICommands["ConnectionRenameConnectionUI"] = "connection-rename-connection-ui"; + // + UICommands["ExportUnderlyingDataToCSVUI"] = "export-to-csv-with-progress-ui"; + // + UICommands["ConnectODBCUI"] = "connect-odbc-ui"; + // + UICommands["CopyCrosstab"] = "copy-crosstab"; + // + UICommands["CopyData"] = "copy-data"; + // + UICommands["CopyDrillPathFieldsUI"] = "copy-drill-path-fields-ui"; + // + UICommands["CopyFieldsDefnUI"] = "copy-fields-defn-ui"; + // + UICommands["CopyImage"] = "copy-image"; + // + UICommands["CopyImageDashboard"] = "copy-image-dashboard"; + // + UICommands["CopyImageWorksheet"] = "copy-image-worksheet"; + // + UICommands["CopyImageStory"] = "copy-image-story"; + // + UICommands["CopyWorksheetFormatting"] = "copy-formatting"; + // + UICommands["CreateCalculatedSetUI"] = "create-calculated-set-ui"; + // + UICommands["CreateCalculationUI"] = "create-calculation-ui"; + // + UICommands["CreateCombinedFieldUI"] = "create-combined-field-ui"; + // + UICommands["CreateConnectionUI"] = "create-connection-ui"; + // + UICommands["CreateDateBinUI"] = "create-Date-bin-ui"; + // + UICommands["CreateGroupSelectionUI"] = "create-group-selection-ui"; + // + UICommands["CreateGroupUI"] = "create-group-ui"; + // + UICommands["CreateIdentitySet"] = "create-user-filter"; + // + UICommands["CreateLeafConnectionUI"] = "create-leaf-connection-ui"; + // + UICommands["CreateNumericBinsUI"] = "create-numeric-bins-ui"; + // + UICommands["CreateSetUI"] = "create-set-ui"; + // + UICommands["CustomDateAggregationUI"] = "custom-date-aggregation-ui"; + // + UICommands["CutDrillPathFieldsUI"] = "cut-drill-path-fields-ui"; + // + UICommands["CutFieldsDefnUI"] = "cut-fields-defn-ui"; + // + UICommands["DeactivateDashboard"] = "deactivate-dashboard"; + // + UICommands["DeleteCookies"] = "delete-cookies"; + // + UICommands["DeleteFieldsUI"] = "delete-fields-ui"; + // + UICommands["DeleteSheetUI"] = "delete-sheet-ui"; + // + UICommands["DescribeAdhocClusterUI"] = "describe-adhoc-cluster-ui"; + // + UICommands["DescribeDrillPathUI"] = "describe-drillpath-ui"; + // + UICommands["DescribeFieldUI"] = "describe-field-ui"; + // + UICommands["DescribeForecastUI"] = "describe-forecast-ui"; + // + UICommands["DescribeSchemaDrillPathUI"] = "describe-schema-drillpath-ui"; + // + UICommands["DescribeTrendLine"] = "describe-trend-line"; + // + UICommands["DescribeTrendModel"] = "describe-trend-model"; + // + UICommands["OpenDiscoverPaneLinks"] = "open-discover-pane-links"; + // + UICommands["DismissGoToWorksheetTooltipUI"] = "dismiss-go-to-worksheet-tooltip-ui"; + // + UICommands["DownloadCopyDataSource"] = "download-copy-data-source"; + // + UICommands["DrilldownUI"] = "drilldown-ui"; + // + UICommands["DropSchemaSelOnShelfUI"] = "drop-schema-sel-on-shelf-ui"; + // + UICommands["DropUI"] = "drop-ui"; + // + UICommands["DuplicateDataSourceUI"] = "duplicate-datasource-ui"; + // + UICommands["DuplicateSheetAsCrosstab"] = "duplicate-sheet-as-crosstab"; + // + UICommands["DuplicateSheetOrCrosstabUI"] = "duplicate-sheet-or-crosstab-ui"; + // + UICommands["DuplicateSheetUI"] = "duplicate-sheet-ui"; + // + UICommands["EditAliasesUI"] = "edit-aliases-ui"; + // + UICommands["EditAnnotation"] = "edit-annotation"; + // + UICommands["EditAxisUI"] = "edit-axis-ui"; + // + UICommands["EditCalculatedSetUI"] = "edit-calculated-set-ui"; + // + UICommands["EditCalculationUI"] = "edit-calculation-ui"; + // + UICommands["EditCaptionUI"] = "edit-caption"; + // + UICommands["EditCombinedFieldUI"] = "edit-combined-field"; + // + UICommands["EditCopyFieldUI"] = "edit-copy-field-ui"; + // + UICommands["EditDataSourceUI"] = "edit-datasource-ui"; + // + UICommands["EditDataSourceFieldAliases"] = "edit-datasource-field-aliases"; + // + UICommands["EditDataSourceFiltersUI"] = "edit-datasource-filters-ui"; + // + UICommands["EditDataSourceSitePathsUI"] = "edit-datasource-site-paths-ui"; + // + UICommands["EditDateBinUI"] = "edit-date-bin-ui"; + // + UICommands["EditDefaultSortUI"] = "edit-default-sort-ui"; + // + UICommands["EditDropLinesUI"] = "edit-drop-lines-ui"; + // + UICommands["EditDropFieldUI"] = "edit-drop-field-ui"; + // + UICommands["EditDataSourceRelationshipsUI"] = "edit-datasource-relationships-ui"; + // + UICommands["EditEnumeratedSetUI"] = "edit-enumerated-set"; + // + UICommands["EditFilterQuickFilter"] = "edit-filter-quick-filter"; + // + UICommands["EditFilterUI"] = "edit-filter-ui"; + // + UICommands["EditForecastUI"] = "edit-forecast-ui"; + // + UICommands["EditGroupUI"] = "edit-group-ui"; + // + UICommands["EditGroupValue"] = "edit-group-value"; + // + UICommands["EditGroupValueLabel"] = "edit-group-value-label"; + // + UICommands["EditLegendGroupValueUI"] = "edit-group-value-legend"; + // + UICommands["EditImageUI"] = "edit-image-ui"; + // + UICommands["EditLegendMemberAliasUI"] = "edit-legend-member-alias-ui"; + // + UICommands["EditLegendTitleUI"] = "edit-legend-title-ui"; + // + UICommands["EditMarkColorUI"] = "edit-mark-color-ui"; + // + UICommands["EditMarkShapeUI"] = "edit-mark-shape-ui"; + // + UICommands["EditMemberAlias"] = "edit-member-alias"; + // + UICommands["EditMemberAliasLabel"] = "edit-member-alias-label"; + // + UICommands["EditPageTitleUI"] = "edit-page-title-ui"; + // + UICommands["EditParameterCtrlTitle"] = "edit-param-control-title"; + // + UICommands["EditPdfPageSelectionUI"] = "edit-pdf-page-selection-ui"; + // + UICommands["EditPrimaryAliasesUI"] = "edit-primary-aliases-ui"; + // + UICommands["EditReferenceLine"] = "edit-reference-line"; + // + UICommands["EditSchemaCalculationUI"] = "edit-schema-calculation-ui"; + // + UICommands["EditSchemaCalculationRangeUI"] = "edit-schema-calculation-range-ui"; + // + UICommands["EditSchemaCaptionUI"] = "edit-schema-caption-ui"; + // + UICommands["EditSchemaFieldAliasUI"] = "edit-schema-field-alias-ui"; + // + UICommands["ResetSchemaCaptionUI"] = "reset-schema-field-alias-ui"; + // + UICommands["ResetMultipleSchemaCaptionsUI"] = "reset-multiple-schema-field-alias-ui"; + // + UICommands["EditSchemaNumericBinsUI"] = "edit-schema-numeric-bins-ui"; + // + UICommands["EditSetUI"] = "edit-set-ui"; + // + UICommands["EditTitleQuickFilter"] = "edit-title-quick-filter"; + // + UICommands["EditTitleUI"] = "edit-title"; + // + UICommands["EditTooltipUI"] = "edit-tooltip"; + // + UICommands["EditTrendLinesUI"] = "edit-trend-lines-ui"; + // + UICommands["EditUserDescriptionUI"] = "edit-user-description-ui"; + // + UICommands["EditWMSMapTileServer"] = "edit-wms-map-tile-server"; + // + UICommands["EditZoneParam"] = "edit-zone-param"; + // + UICommands["EditZoneUrl"] = "edit-zone-url"; + // + UICommands["EstablishConnectionUI"] = "establish-connection-ui"; + // + UICommands["EstablishTableauServerConnectionUI"] = "establish-tableau-server-connection-ui"; + // + UICommands["ExecuteUIAutomationButton"] = "execute-ui-button-action"; + // + UICommands["ExecuteUIAutomationComboBox"] = "execute-ui-combo-box-action"; + // + UICommands["ExecuteUIAutomationGenericWidget"] = "execute-ui-generic-widget-action"; + // + UICommands["ExecuteUIAutomationLabel"] = "execute-ui-label-action"; + // + UICommands["ExecuteUIAutomationMenu"] = "execute-ui-menu-action"; + // + UICommands["ExecuteUIAutomationItemView"] = "execute-ui-item-view-action"; + // + UICommands["ExecuteUIAutomationTextBox"] = "execute-ui-text-box-action"; + // + UICommands["ExecuteUIAutomationToggleButton"] = "execute-ui-toggle-button-action"; + // + UICommands["ExecuteUIAutomationSlider"] = "execute-ui-slider-action"; + // + UICommands["ExecuteUIAutomationWindow"] = "execute-ui-window-action"; + // + UICommands["ExecuteUIAutomationWebView"] = "execute-ui-web-view-action"; + // + UICommands["ExecuteUIAutomationTab"] = "execute-ui-tab-action"; + // + UICommands["ExecuteUIAutomationTextBrowser"] = "execute-ui-text-browser-action"; + // + UICommands["ExitApplication"] = "exit-application"; + // + UICommands["ExportData"] = "export-data"; + // + UICommands["ExportDataSourceUI"] = "export-datasource-ui"; + // + UICommands["ExportPackagedWorkbook"] = "export-packaged"; + // + UICommands["ExportWorkbookSheetsUI"] = "export-workbook-sheets-ui"; + // + UICommands["ExtSvcConfigUI"] = "ext-svc-config-ui"; + // + UICommands["ExtractHistory"] = "extract-history"; + // + UICommands["ExtractPropertiesUI"] = "extract-properties-ui"; + // + UICommands["ExtractUI"] = "extract-ui"; + // + UICommands["FilterFieldLabelUI"] = "filter-field-label-ui"; + // + UICommands["FormatAnnotation"] = "format-annotation"; + // + UICommands["FormatAxisUI"] = "format-axis-ui"; + // + UICommands["FormatCaptionTitleUI"] = "format-caption-title"; + // + UICommands["FormatField"] = "format-pane"; + // + UICommands["FormatFieldLabelUI"] = "format-field-label-ui"; + // + UICommands["FormatLabel"] = "format-label"; + // + UICommands["FormatLegendsUI"] = "format-legends-ui"; + // + UICommands["FormatReferenceLine"] = "format-reference-line"; + // + UICommands["FormatUI"] = "format-ui"; + // + UICommands["FullScreen"] = "fullscreen"; + // + UICommands["GetDashboardSidePaneMode"] = "get-dashboard-sidepane-mode"; + // + UICommands["GetDebuggingInfo"] = "get-debugging-info"; + // + UICommands["GetIconPathForEncodingType"] = "get-icon-path-for-encoding-type"; + // + UICommands["GetIconPathForPrimitiveType"] = "get-icon-path-for-primitive-type"; + // + UICommands["GetTableOptionsPresModel"] = "get-table-options-pres-model"; + // + UICommands["GetWindowNameUI"] = "get-window-name"; + // + UICommands["GetWorksheetSidePaneMode"] = "get-worksheet-sidepane-mode"; + // + UICommands["GetHiddenSheets"] = "get-hidden-sheets"; + // + UICommands["GetOpenPaneMRUs"] = "get-open-pane-mrus"; + // + UICommands["GetOpenPaneSampleWorkbooks"] = "get-open-pane-sample-workbooks"; + // + UICommands["GetRetargetDataSourcePresModelUI"] = "get-retarget-datasource-pres-model-ui"; + // + UICommands["GetSchemaViewerPresModel"] = "get-schema-viewer-pres-model"; + // + UICommands["GetSelectedSheets"] = "get-selected-sheets"; + // + UICommands["GetSheetSorterThumbnail"] = "get-sheet-sorter-thumbnail"; + // + UICommands["GetSheetTabUIThumbnail"] = "get-sheet-tab-ui-thumbnail"; + // + UICommands["GetSheetTabUIText"] = "get-sheet-tab-ui-text"; + // + UICommands["GetVisibleTreeItems"] = "get-visible-tree-items"; + // + UICommands["GotoSheetRange"] = "goto"; + // + UICommands["GotoURL"] = "goto-url"; + // + UICommands["HideCaptionUI"] = "hide-caption"; + // + UICommands["HideFilmstripUI"] = "hide-filmstrip-ui"; + // + UICommands["HideTitleUI"] = "hide-title"; + // + UICommands["HideZoneUI"] = "hide-zone-ui"; + // + UICommands["HideAllSheetsUI"] = "hide-all-sheets-ui"; + // + UICommands["UnhideAllSheetsUI"] = "unhide-all-sheets-ui"; + // + UICommands["ImportLocalDataUI"] = "import-local-data-ui"; + // + UICommands["ImportMapSource"] = "import-map-source"; + // + UICommands["ImportMapSourceUI"] = "import-map-source-ui"; + // + UICommands["ImportWorkbookUI"] = "import-workbook-ui"; + // + UICommands["LoadDefaultFormattingUI"] = "load-formatting-ui"; + // + UICommands["LocateFieldUI"] = "locate-field-ui"; + // + UICommands["LogMemoryUsage"] = "log-memory-usage"; + // + UICommands["ManageLicensing"] = "manage-licensing"; + // + UICommands["ManageMapbox"] = "manage-mapbox"; + // + UICommands["ManagePublicWorkbooks"] = "manage-public"; + // + UICommands["ManageMapServices"] = "manage-map-services"; + // + UICommands["MapLayersUI"] = "map-layers-ui"; + // + UICommands["ManageWMS"] = "manage-wms"; + // + UICommands["UpgradeDataSourcesUI"] = "upgrade-datasources-ui"; + // + UICommands["UpgradeDataSourceUI"] = "upgrade-datasource-ui"; + // + UICommands["MoveRepository"] = "move-repository"; + // + UICommands["NewSchemaDrillPathUI"] = "new-schema-drill-path-ui"; + // + UICommands["NewUIDashboard"] = "new-dashboard-ui"; + // + UICommands["NewUIWorksheet"] = "new-worksheet-ui"; + // + UICommands["NewUIStoryboard"] = "new-storyboard-ui"; + // + UICommands["NewWorkbook"] = "new-workbook"; + // + UICommands["NextSheet"] = "next-sheet"; + // + UICommands["NonRangedEditReferenceLine"] = "non-ranged-edit-reference-line"; + // + UICommands["OpenBookmark"] = "open-bookmark"; + // + UICommands["OpenFromWorkgroup"] = "open-workbook-from-workgroup"; + // + UICommands["OpenMapSource"] = "open-map-source"; + // + UICommands["OpenMapSourceUI"] = "open-map-source-ui"; + // + UICommands["OpenSampleWorkbook"] = "open-sample-workbook"; + // + UICommands["OpenWorkbook"] = "open-workbook"; + // + UICommands["OpenRecentWorkbook"] = "open-recent-workbook"; + // + UICommands["OpenOtherFiles"] = "open-other-files"; + // + UICommands["OptimizeExtractUI"] = "optimize-extract-ui"; + // + UICommands["PageSetup"] = "page-setup"; + // + UICommands["Paste"] = "paste"; + // + UICommands["PasteFieldsDefnUI"] = "paste-fields-defn-ui"; + // + UICommands["PasteWorksheetFormatting"] = "paste-formatting"; + // + UICommands["PDFExport"] = "export-pdf"; + // + UICommands["PerspectivesUI"] = "perspectives-ui"; + // + UICommands["PresentationMode"] = "presentation-mode"; + // + UICommands["Print"] = "print"; + // + UICommands["PromptScript"] = "prompt-command"; + // + UICommands["PropertiesDataSourceUI"] = "properties-datasource-ui"; + // + UICommands["PublishDatasourceToWorkgroup"] = "publish-datasource-to-workgroup"; + // + UICommands["PublishDatasourceToWorkgroupFromData"] = "publish-datasource-to-workgroup-from-data"; + // + UICommands["PublishDatasourceToWorkgroupRange"] = "publish-datasource-to-workgroup-range"; + // + UICommands["PublishWorkbookToWorkgroup"] = "publish-workbook-to-workgroup"; + // + UICommands["PublishDatasourceToWorkgroupFromWorkbookData"] = "publish-datasource-to-workgroup-from-workbook-data"; + // + UICommands["PromptForDataSourceFileUI"] = "prompt-for-datasource-file-ui"; + // + UICommands["PromptUnknownWDCUrlUI"] = "prompt-unknown-wdc-url-ui"; + // + UICommands["QueryDataSourceUI"] = "query-datasource-ui"; + // + UICommands["QuickFilterFieldLabelUI"] = "quick-filter-field-label-ui"; + // + UICommands["QuickTableCalcUI"] = "quick-table-calc-ui"; + // + UICommands["ReconnectMapSourceUI"] = "reconnect-map-source-ui"; + // + UICommands["RecordPerformance"] = "record-perf"; + // + UICommands["RefreshAllExtractsUI"] = "refresh-all-extracts-ui"; + // + UICommands["RefreshAllThumbnailsUI"] = "refresh-all-thumbnails"; + // + UICommands["RefreshAutoExtractUI"] = "refresh-auto-extract-ui"; + // + UICommands["RefreshDataSourceUI"] = "refresh-datasource-ui"; + // + UICommands["RefreshExtractUI"] = "refresh-extract-ui"; + // + UICommands["RefreshFromSourceUI"] = "refresh-from-source-ui"; + // + UICommands["RefreshLocalDataUI"] = "refresh-local-data-ui"; + // + UICommands["RefreshThumbnailUI"] = "refresh-thumbnail"; + // + UICommands["ReleaseMemory"] = "release-memory"; + // + UICommands["RemoveAnnotation"] = "remove-annotation"; + // + UICommands["RemoveExtractUI"] = "remove-extract-ui"; + // + UICommands["RemoveMRUItem"] = "remove-mru"; + // + UICommands["RemoveSavedDataSourceUI"] = "remove-saved-datasource"; + // + UICommands["RemoveSheetFromDashboardUI"] = "remove-sheet-from-dashboard-ui"; + // + UICommands["RemoveTableUI"] = "remove-table-ui"; + // + UICommands["RenameDataSourceUI"] = "rename-datasource-ui"; + // + UICommands["RenameSchemaFieldFolderUI"] = "rename-field-folder-ui"; + // + UICommands["RenameSchemaDrillPathUI"] = "rename-schema-drillpath-ui"; + // + UICommands["RenameSheetUI"] = "rename-sheet-ui"; + // + UICommands["ReorderSheetsUI"] = "reorder-sheets-ui"; + // + UICommands["ReplaceDataSourceWithDataServerDataSourceUI"] = "replace-datasource-with-data-server-datasource-ui"; + // + UICommands["ReplaceFieldUI"] = "replace-field-ui"; + // + UICommands["ResetCaptionUI"] = "reset-caption-ui"; + // + UICommands["ResetCards"] = "reset-cards"; + // + UICommands["ResetLocalDataUI"] = "remove-local-data-ui"; + // + UICommands["ResetMessages"] = "reset-messages"; + // + UICommands["StartOnlineSyncClient"] = "start-online-sync-client"; + // + UICommands["ResetTitleUI"] = "reset-title-ui"; + // + UICommands["ResetToDefaultsMapCard"] = "reset-map-to-defaults"; + // + UICommands["ResetWorkbook"] = "revert-workbook-ui"; + // + UICommands["RetargetDataSource"] = "retarget-datasource"; + // + UICommands["RetargetDataSourceUI"] = "retarget-datasource-ui"; + // + UICommands["SaveAsWorkbook"] = "save-as-workbook"; + // + UICommands["SaveBookmark"] = "save-bookmark"; + // + UICommands["SaveDebuggingWorkbook"] = "save-debugging-workbook"; + // + UICommands["SaveDefaultFormattingUI"] = "save-formatting-ui"; + // + UICommands["SaveWorkbook"] = "save-workbook"; + // + UICommands["SchemaDefaultMemberUI"] = "schema-default-member-ui"; + // + UICommands["ScrollSheet"] = "scroll-sheet"; + // + UICommands["SetAccountsDimension"] = "set-accounts-dimension"; + // + UICommands["SetActiveConnectionUI"] = "set-active-connection-ui"; + // + UICommands["SetAnalyticsDropTargetVisibility"] = "set-analytics-drop-target-visibility"; + // + UICommands["SetDashboardSidePaneMode"] = "set-dashboard-sidepane-mode"; + // + UICommands["SetDefaultDateFormatUI"] = "set-default-date-format-ui"; + // + UICommands["SetDefaultLocationUI"] = "set-default-location-ui"; + // + UICommands["SetDefaultMapSourceUI"] = "set-default-mapsource-ui"; + // + UICommands["SetDefaultTextFormatUI"] = "set-default-text-format-ui"; + // + UICommands["SetDefaultUtilityMember"] = "set-default-utility-member"; + // + UICommands["SetFreeFormDashboardUI"] = "set-free-form-dashboard-ui"; + // + UICommands["SetFilterSharedUI"] = "set-filter-shared-ui"; + // + UICommands["SetKey"] = "set-key"; + // + UICommands["SetProductAutoUpdate"] = "set-auto-update"; + // + UICommands["SetQueryFailure"] = "set-query-failure"; + // + UICommands["SetRendering"] = "set-rendering"; + // + UICommands["SetRuntimeImmediateMode"] = "set-runtime-immediate-mode"; + // + UICommands["SetUILanguage"] = "set-ui-language"; + // + UICommands["SetWorkbookLocaleUI"] = "set-workbook-locale-ui"; + // + UICommands["SetWorksheetSidePaneMode"] = "set-worksheet-sidepane-mode"; + // + UICommands["SetZoneFixedSizeUI"] = "set-zone-fixed-size-ui"; + // + UICommands["SetsInOutUI"] = "show-in-out-sets"; + // + UICommands["ShapeLegendEditUI"] = "shape-legend-edit-ui"; + // + UICommands["ShowCloudFileOAuthPromptAndSelectionUI"] = "show-cloudfile-oauth-prompt-and-selection-ui"; + // + UICommands["ShowConnectionAuthUI"] = "show-connection-auth-ui"; + // + UICommands["ShowConnectionAuthAndEstablishConnectionUI"] = "show-connection-auth-and-establish-connection-ui"; + // + UICommands["ShowConnectTab"] = "show-connect-tab"; + // + UICommands["ShowCustomSplitDialogUI"] = "show-custom-split-dialog-ui"; + // + UICommands["ShowDocument"] = "document"; + // + UICommands["ShowFeatureFlagDialog"] = "show-feature-flag-dialog"; + // + UICommands["ShowFieldFormatUI"] = "show-field-format-ui"; + // + UICommands["ShowFieldInSchemaUI"] = "show-field-in-schema"; + // + UICommands["ShowFilmstripUI"] = "show-filmstrip-ui"; + // + UICommands["ShowGoogleSheetsSelectionUI"] = "show-google-sheets-selection-ui"; + // + UICommands["ShowHelp"] = "show-help"; + // + UICommands["ShowHideDashboardSheetUI"] = "show-hide-dashboard-sheet-ui"; + // + UICommands["ShowHideStoryboardSheetUI"] = "show-hide-storyboard-sheet-ui"; + // + UICommands["ShowGraphicsAPI"] = "show-graphics-api-command"; + // + UICommands["ShowMapOptionsDialog"] = "show-map-options-dialog"; + // + UICommands["ShowMeasuresUI"] = "show-measures-ui"; + // + UICommands["ShowMeCycleUI"] = "show-me-cycle-ui"; + // + UICommands["ShowMeHideUI"] = "show-me-hide-ui"; + // + UICommands["ShowMembersUI"] = "show-members-ui"; + // + UICommands["ShowMeToggleUI"] = "show-me-toggle-ui"; + // + UICommands["ShowOAuthPromptUI"] = "show-oauth-prompt-ui"; + // + UICommands["ShowParameterControl"] = "show-parameter-control"; + // + UICommands["ShowPublicStatusDialog"] = "show-public-status-dialog"; + // + UICommands["ShowPublicQuotaExceededDialog"] = "show-public-quota-exceeded-dialog"; + // + UICommands["ShowPublishDatasourceToWorkgroupDialog"] = "show-publish-datasource-to-workgroup-dialog"; + // + UICommands["ShowQueryBandingAndInitialSQLDialogUI"] = "show-query-banding-and-initial-sql-dialog-ui"; + // + UICommands["ShowQuickFilter"] = "show-quickfilter"; + // + UICommands["ShowQuickFilterUI"] = "show-quickfilter-ui"; + // + UICommands["ShowRuntimeIndicator"] = "show-runtime-indicator"; + // + UICommands["ShowSheetSorter"] = "sheet-sorter"; + // + UICommands["ShowTableOptionsDialog"] = "show-table-options-dialog"; + // + UICommands["ShowWebDataConnectorUI"] = "show-web-data-connector-ui"; + // + UICommands["ShowWidgetSandboxUI"] = "show-widget-sandbox-ui"; + // + UICommands["SizeLegendEditUI"] = "size-legend-edit-ui"; + // + UICommands["SleepUI"] = "sleep-ui"; + // + UICommands["SortAscendingFieldLabelUI"] = "sort-ascending-field-label-ui"; + // + UICommands["SortDescendingFieldLabelUI"] = "sort-descending-field-label-ui"; + // + UICommands["SortFieldLabelUI"] = "sort-field-label-ui"; + // + UICommands["SortUI"] = "sort-ui"; + // + UICommands["SplitFieldUI"] = "split-field-ui"; + // + UICommands["StackMarksUI"] = "stack-marks-ui"; + // + UICommands["StartFileConnectionUI"] = "start-file-connection-ui"; + // + UICommands["StartPillEditUI"] = "start-pill-edit-ui"; + // + UICommands["SwitchToConnectTab"] = "switch-to-connect-tab"; + // + UICommands["SwitchToDocument"] = "switch-to-document"; + // + UICommands["SwitchToSheetSorter"] = "switch-to-sheet-sorter"; + // + UICommands["TableCalcAddressUI"] = "table-calc-address-ui"; + // + UICommands["TableCalcIgnoreUI"] = "table-calc-ignore-ui"; + // + UICommands["TableCalcOrderingUI"] = "table-calc-ordering-ui"; + // + UICommands["TableCalcUI"] = "table-calc-ui"; + // + UICommands["ToggleConnectPaneUI"] = "toggle-connect-pane"; + // + UICommands["ToggleFilmstripUI"] = "toggle-filmstrip-ui"; + // + UICommands["ToggleINDJoinSemanticsUI"] = "toggle-ind-join-semantics-ui"; + // + UICommands["TogglePinMRUItem"] = "toggle-pin-mru"; + // + UICommands["ToggleReferentialIntegrityUI"] = "toggle-referential-integrity-ui"; + // + UICommands["ToggleStartPageUI"] = "toggle-start-page"; + // + UICommands["TrackMemory"] = "track-memory"; + // + UICommands["TrendLinesFlagUI"] = "trend-lines-ui"; + // + UICommands["UpdateDefaultsMapCard"] = "update-map-defaults"; + // + UICommands["UpgradeExtractsUI"] = "upgrade-extracts-ui"; + // + UICommands["UpgradeExtractUI"] = "upgrade-extract-ui"; + // + UICommands["UseExtractUI"] = "use-extract-ui"; + // + UICommands["UseMemory"] = "use-memory"; + // + UICommands["UtilityDimensionUI"] = "utility-dimension-ui"; + // + UICommands["ValidateExtractCredentialsUI"] = "validate-extract-credentials-ui"; + // + UICommands["ViewCard"] = "view-card"; + // + UICommands["ViewTitleCard"] = "view-title-card"; + // + UICommands["ViewSummaryCard"] = "view-summary-card"; + // + UICommands["ViewCaptionCard"] = "view-caption-card"; + // + UICommands["ViewColumnsShelf"] = "view-columns-shelf"; + // + UICommands["ViewRowsShelf"] = "view-rows-shelf"; + // + UICommands["ViewPagesShelf"] = "view-pages-shelf"; + // + UICommands["ViewFiltersShelf"] = "view-filters-shelf"; + // + UICommands["ViewMeasuresShelf"] = "view-measures-shelf"; + // + UICommands["ViewMarksShelf"] = "view-marks-shelf"; + // + UICommands["ViewCurrentPageCard"] = "view-current-page-card"; + // + UICommands["ViewData"] = "view-data"; + // + UICommands["ViewSQLDataUI"] = "view-sql-data-ui"; + // + UICommands["ViewDataSourceData"] = "view-datasource-data"; + // + UICommands["ViewLegend"] = "view-legend"; + // + UICommands["ViewSidePane"] = "view-side-pane"; + // + UICommands["ViewStatusBar"] = "view-statusbar"; + // + UICommands["ViewSummaryDetail"] = "view-summary-detail"; + // + UICommands["ViewTableData"] = "view-table-data"; + // + UICommands["ViewToolBar"] = "view-toolbar"; + // + UICommands["WebViewEnableJavascript"] = "webview-enable-javascript"; + // + UICommands["WebViewEnablePlugins"] = "webview-enable-plugins"; + // + UICommands["WebViewBlockPopups"] = "webview-block-popups"; + // + UICommands["WebViewEnableURLHoverActions"] = "webview-enable-url-hover-actions"; + // + UICommands["WorkgroupChangeDataserver"] = "workgroup-change-dataserver"; + // + UICommands["WorkgroupChangeServer"] = "workgroup-change-server"; + // + UICommands["WorkgroupChangeUser"] = "workgroup-change-user"; + // + UICommands["WorkgroupRemoveLastServer"] = "workgroup-remove-last-server"; + })(UICommands = exports.UICommands || (exports.UICommands = {})); + var SrvCommands; + (function (SrvCommands) { + // pings the server to test if the session is expired + SrvCommands["PingSession"] = "ping-session"; + // Applies snapshot from comments to the viz. + SrvCommands["ApplyCustomizedView"] = "apply-customized-view"; + // Refreshes VQLSession Data + SrvCommands["RefreshData"] = "refresh-data"; + })(SrvCommands = exports.SrvCommands || (exports.SrvCommands = {})); + (function (DocCommands) { + // Returns whether date properties should be enabled + DocCommands["GetDataSourceDatePropertiesAreEnabled"] = "get-datasource-date-properties-are-enabled"; + // Get presmodel to populate date properties dialog + DocCommands["GetDataSourceDateProperties"] = "get-datasource-date-properties"; + // Apply new settings for date properties + DocCommands["EditDataSourceDateProperties"] = "edit-datasource-date-properties"; + // Apply data source delta to data source + DocCommands["ApplyDataSourceDelta"] = "apply-datasource-delta"; + // Generate data source delta from local data source + DocCommands["GetDataSourceDelta"] = "get-datasource-delta"; + // Gets the pres model for the Save Datasource dialog + DocCommands["GetWebSaveDatasourceDialog"] = "get-web-save-datasource-dialog"; + // Creates a dialog in the browser to rename the datasource + DocCommands["WebRenameDatasourceDialog"] = "web-rename-datasource-dialog"; + // Switches the view to the data tab for editing + DocCommands["WebEditDataSource"] = "web-edit-data-source"; + // Toggles joining on null values + DocCommands["ToggleINDJoinSemantics"] = "toggle-ind-join-semantics"; + // Join Null Values to Null Values + DocCommands["ToggleINDJoinSemanticsWrapper"] = "toggle-indjoin-semantics-wrapper"; + // Toggles referential integrity + DocCommands["ToggleReferentialIntegrity"] = "toggle-referential-integrity"; + // Retrieves list of summary objects, one for each connection in a datasource. + DocCommands["GetConnectionDescriptionSummaryPresModels"] = "get-connection-description-summary-pres-models"; + // Gets the axis options . + DocCommands["GetAxisOptions"] = "get-axis-options"; + // Reset the axis options . + DocCommands["ResetAxisOptions"] = "reset-axis-options"; + // Show axis edit dialog + DocCommands["ShowEditAxisDialog"] = "show-edit-axis-dialog"; + // Sets the axis direction + DocCommands["SetAxisReversed"] = "set-axis-reversed"; + // Sets the axis scale type + DocCommands["SetAxisScaleType"] = "set-axis-scale-type"; + // Sets the main title of a quantitative axis + DocCommands["SetAxisTitle"] = "set-axis-title"; + // Sets the subtitle of a quantitative axis + DocCommands["SetAxisSubtitle"] = "set-axis-subtitle"; + // Sets whether we should use the automatic subtitle for a quantitative axis + DocCommands["SetAxisUseAutomaticSubtitle"] = "set-axis-use-automatic-subtitle"; + // Sets the axis range type of a quantitative axis + DocCommands["SetAxisExtentStartType"] = "set-axis-extent-start-type"; + // Sets the axis range type of a quantitative axis + DocCommands["SetAxisExtentEndType"] = "set-axis-extent-end-type"; + // Sets the axis range type of a quantitative axis + DocCommands["SetBothAxisExtentsType"] = "set-both-axis-extents-type"; + // Sets whether or not to force-include zero on a quantitative axis + DocCommands["SetAxisIncludeZero"] = "set-axis-include-zero"; + // Sets new min/max range endings for axis + DocCommands["SetAxisRangeEnd"] = "set-axis-range-end"; + // Sets new min/max range endings for axis + DocCommands["SetAxisRangeStart"] = "set-axis-range-start"; + // Synchronize dual axes on a folded quantitative axis + DocCommands["SetAxisFoldState"] = "set-axis-fold-state"; + // Set the major tick mark state + DocCommands["SetMajorTickMarkState"] = "set-major-tick-mark-state"; + // Set the minor tick mark state + DocCommands["SetMinorTickMarkState"] = "set-minor-tick-mark-state"; + // Set the major tick mark origin + DocCommands["SetMajorTickMarkOrigin"] = "set-major-tick-mark-origin"; + // Set the minor tick mark origin + DocCommands["SetMinorTickMarkOrigin"] = "set-minor-tick-mark-origin"; + // Set the major tick mark spacing + DocCommands["SetMajorTickMarkSpacing"] = "set-major-tick-mark-spacing"; + // Set the minor tick mark spacing + DocCommands["SetMinorTickMarkSpacing"] = "set-minor-tick-mark-spacing"; + // Set the major tick mark units + DocCommands["SetMajorTickMarkUnits"] = "set-major-tick-mark-units"; + // Set the minor tick mark units + DocCommands["SetMinorTickMarkUnits"] = "set-minor-tick-mark-units"; + // + DocCommands["BoundingBoxPan"] = "bounding-box-pan"; + // + DocCommands["OnToggleAxisRanges"] = "on-toggle-axis-ranges"; + // + DocCommands["PanePan"] = "pane-pan"; + // + DocCommands["PaneZoom"] = "pane-zoom"; + // + DocCommands["PaneZoomFactor"] = "pane-zoom-factor"; + // + DocCommands["PaneZoomPan"] = "pane-zoom-pan"; + // + DocCommands["ReorderFoldedAxes"] = "reorder-folded-axes"; + // + DocCommands["ResetAxisRange"] = "reset-axis-range"; + // + DocCommands["SelectAxisTuples"] = "select-axis-tuples"; + // + DocCommands["SwapReferenceLineFields"] = "swap-reference-line-fields"; + // + DocCommands["SynchronizeAxis"] = "synchronize-axis"; + // + DocCommands["ToggleDualAxis"] = "toggle-dual-axis"; + // + DocCommands["ZoomLevel"] = "zoom-level"; + })(DocCommands = exports.DocCommands || (exports.DocCommands = {})); + + +/***/ }, +/* 84 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(80); + /** + * Registry which contains mappings from an Api VerbId to a pres-layer command. + * This includes the parameters and return values of the command as well + * + * @export + * @class CommandMappingRegistry + */ + var CommandMappingRegistry = (function () { + /** + * Creates an instance of CommandMappingRegistry. + * @memberof CommandMappingRegistry + */ + function CommandMappingRegistry() { + this._commands = {}; + } + /** + * Adds a new command to the registry + * + * @param {CommandRegistration} command + * @memberof CommandMappingRegistry + */ + CommandMappingRegistry.prototype.addCommand = function (command) { + this._commands[command.apiVerbId] = command; + }; + /** + * Whether or not this registry contains a definition for this ApiVerbId + * + * @param {ApiVerbId} apiVerbId + * @returns {boolean} + * @memberof CommandMappingRegistry + */ + CommandMappingRegistry.prototype.hasCommand = function (apiVerbId) { + if (!this._commands.hasOwnProperty(apiVerbId)) { + return false; + } + if (!this._commands[apiVerbId]) { + return false; + } + return true; + }; + /** + * Gets the command registration for this command id or throws if it doesn't exist + * + * @param {ApiVerbId} apiVerbId + * @returns {CommandRegistration} + * @memberof CommandMappingRegistry + */ + CommandMappingRegistry.prototype.getCommand = function (apiVerbId) { + if (!this.hasCommand(apiVerbId)) { + throw api_utils_1.TableauException.error(CommandMappingRegistry.UNKNOWN_APIVERB, [apiVerbId]); + } + return this._commands[apiVerbId]; + }; + CommandMappingRegistry.UNKNOWN_APIVERB = 'Unknown ApiVerb: %1'; + return CommandMappingRegistry; + }()); + exports.CommandMappingRegistry = CommandMappingRegistry; + + +/***/ }, +/* 85 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var api_utils_1 = __webpack_require__(80); + /** + * This is an enum used only internally by the api-core project. + * This enum represents the difference namespaces available for commands. + */ + var CommandNamespace; + (function (CommandNamespace) { + CommandNamespace["TabDoc"] = "tabdoc"; + CommandNamespace["TabSrv"] = "tabsrv"; + CommandNamespace["TabUI"] = "tabui"; + })(CommandNamespace = exports.CommandNamespace || (exports.CommandNamespace = {})); + /** + * Represents an input or output paramter for a command. + * + * @export + * @class CommandParameter + */ + var CommandParameter = (function () { + /** + * Creates an instance of CommandParameter. + * @param {ApiParameterId} apiId + * @param {PresLayerParameterId} presLayerId + * @param {boolean} [isOptional] + * @memberof CommandParameter + */ + function CommandParameter(_apiId, _presLayerId, _isOptional) { + this._apiId = _apiId; + this._presLayerId = _presLayerId; + this._isOptional = _isOptional; + } + Object.defineProperty(CommandParameter.prototype, "apiId", { + /** + * The Id of the Api Parameter + * + * @readonly + * @type {ApiParameterId} + * @memberof CommandParameter + */ + get: function () { + return this._apiId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandParameter.prototype, "presLayerId", { + /** + * The Id of the Pres Layer Parameter + * + * @readonly + * @type {PresLayerParameterId} + * @memberof CommandParameter + */ + get: function () { + return this._presLayerId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandParameter.prototype, "isOptional", { + /** + * Whether or not this is an optional parameter + * + * @readonly + * @type {boolean} + * @memberof CommandParameter + */ + get: function () { + return !!this._isOptional; + }, + enumerable: true, + configurable: true + }); + return CommandParameter; + }()); + exports.CommandParameter = CommandParameter; + /** + * Represents a the complete mapping of an ApiCommand to its corresponding pres-layer command + * and the conversion of the output value as well + * + * @export + * @class CommandRegistration + * + * @param {ApiVerbId} _apiVerbId the internal api verb ID of this command. + * @param {PresLayerDocCommandId | PresLayerSrvCommandId | PresLayerUICommandId} _commandId + * the pres layer command to execute + * @param {CommandParameter[]} _inputParameters list of parameters to send with this command to the platform. + * @param {CommandParameter} [isOptional] expected return paramters from the platform. + * @param {CommandNamespace} [isOptional] namespace of the command (defaults to TabDoc if not provided). + */ + var CommandRegistration = (function () { + function CommandRegistration(_apiVerbId, _commandId, _inputParameters, _outputParameter, _namespace) { + this._apiVerbId = _apiVerbId; + this._commandId = _commandId; + this._inputParameters = _inputParameters; + this._outputParameter = _outputParameter; + this._namespace = _namespace; + } + Object.defineProperty(CommandRegistration.prototype, "apiVerbId", { + get: function () { + return this._apiVerbId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandRegistration.prototype, "commandId", { + get: function () { + return this._commandId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandRegistration.prototype, "namespace", { + get: function () { + return this._namespace || CommandNamespace.TabDoc; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandRegistration.prototype, "inputs", { + get: function () { + return this._inputParameters || new Array(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandRegistration.prototype, "output", { + get: function () { + return this._outputParameter; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CommandRegistration.prototype, "needsAddInLocator", { + /** + * Whether or not this command requires an add-in locator to be injected into it + * + * @readonly + * @type {boolean} + * @memberof CommandRegistration + */ + get: function () { + for (var _i = 0, _a = this.inputs; _i < _a.length; _i++) { + var input = _a[_i]; + if (input.apiId === api_internal_contract_1.ParameterId.ExtensionLocator) { + return true; + } + } + return false; + }, + enumerable: true, + configurable: true + }); + /** + * Creates a dictionary of pres-layer parameters from the input dictionary + * of api parameters. + * + * @param {ExecuteParameters} parameters - The parameters to convert + * @param {ApiToPresLayerMappingRegistry} apiToPresLayer - mapping to determine the conversion + * @returns {{ [paramId: string]: object; }} - parameters to send to the pres-layer + * @memberof CommandRegistration + */ + CommandRegistration.prototype.createParams = function (parameters, apiToPresLayer) { + var result = {}; + for (var _i = 0, _a = this.inputs; _i < _a.length; _i++) { + var inputParam = _a[_i]; + // First make sure the parameter is there or that it's optional + if (!parameters.hasOwnProperty(inputParam.apiId)) { + if (inputParam.isOptional) { + continue; + } + else { + throw api_utils_1.TableauException.missingParameter([inputParam.apiId]); + } + } + // Find the conversion function for this parameter + var conversionFn = apiToPresLayer.get(inputParam.apiId, inputParam.presLayerId); + // Convert the pres model and insert it into our results object + result[inputParam.presLayerId] = conversionFn(parameters[inputParam.apiId]); + } + return result; + }; + /** + * Processes the result received back after executing a pres-layer command + * + * @param {{ [docParamId: string]: object; }} resultParameters + * @param {PresLayerToApiMappingRegistry} presLayerToApi + * @returns {Model} + * @memberof CommandRegistration + */ + CommandRegistration.prototype.ProcessResult = function (resultParameters, presLayerToApi) { + // TODO: Add error handling + if (this.output === undefined) { + var noOutputModel = {}; + return noOutputModel; + } + if (!resultParameters || !resultParameters.hasOwnProperty(this.output.presLayerId)) { + // if the output result is marked as optional, we don't consider this an error situation and just return an empty model + if (this.output.isOptional) { + return {}; + } + throw api_utils_1.TableauException.missingParameter([this.output.presLayerId]); + } + var conversionFn = presLayerToApi.get(this.output.presLayerId, this.output.apiId); + return conversionFn(resultParameters[this.output.presLayerId]); + }; + return CommandRegistration; + }()); + exports.CommandRegistration = CommandRegistration; + + +/***/ }, +/* 86 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var Events_1 = __webpack_require__(87); + var PresLayerToApiConverter_1 = __webpack_require__(88); + /** + * Simple wrapper which holds a mapping to go from a pres-layer event to an API event + */ + var EventMappingRegistration = (function () { + function EventMappingRegistration(_presLayerId, _apiId, _converter) { + this._presLayerId = _presLayerId; + this._apiId = _apiId; + this._converter = _converter; + } + Object.defineProperty(EventMappingRegistration.prototype, "presLayerId", { + get: function () { + return this._presLayerId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventMappingRegistration.prototype, "apiId", { + get: function () { + return this._apiId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventMappingRegistration.prototype, "converter", { + get: function () { + return this._converter; + }, + enumerable: true, + configurable: true + }); + return EventMappingRegistration; + }()); + exports.EventMappingRegistration = EventMappingRegistration; + var EventMappingRegistryFactory = (function () { + function EventMappingRegistryFactory() { + } + /** + * Creates and populates a new EventMappingRegistry for the specific version number requested + * + * @param {VersionNumber} versionNumber + * @returns {EventMappingRegistry} + */ + EventMappingRegistryFactory.createEventMappingRegistry = function (versionNumber) { + var registry = {}; + registry[Events_1.NotificationId.SelectionChanged] = new EventMappingRegistration(Events_1.NotificationId.SelectionChanged, api_internal_contract_1.NotificationId.SelectedMarksChanged, PresLayerToApiConverter_1.PresLayerToApiConverter.convertVisualId); + registry[Events_1.NotificationId.ParameterChanged] = new EventMappingRegistration(Events_1.NotificationId.ParameterChanged, api_internal_contract_1.NotificationId.ParameterChanged, PresLayerToApiConverter_1.PresLayerToApiConverter.convertFieldCaptionPair); + registry[Events_1.NotificationId.FilterChanged] = new EventMappingRegistration(Events_1.NotificationId.FilterChanged, api_internal_contract_1.NotificationId.FilterChanged, PresLayerToApiConverter_1.PresLayerToApiConverter.convertFilterEvent); + return registry; + }; + return EventMappingRegistryFactory; + }()); + exports.EventMappingRegistryFactory = EventMappingRegistryFactory; + + +/***/ }, +/* 87 */ +/***/ function(module, exports) { + + "use strict"; + /* tslint:disable */ + // ----------------------------------------------------------------------------- + // + // This file is the copyrighted property of Tableau Software and is protected + // by registered patents and other applicable U.S. and international laws and + // regulations. + // + // Unlicensed use of the contents of this file is prohibited. Please refer to + // the NOTICES.txt file for further details. + // + // ----------------------------------------------------------------------------- + // WARNING: Computer generated file. Do not hand modify. + // DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/events-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-events.data', '../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/events-common.template'] + Object.defineProperty(exports, "__esModule", { value: true }); + // Events you can register to receive presentation models + var NotificationId; + (function (NotificationId) { + // Triggered when aliases are to be edited. Used to launch a dialog. + NotificationId["EditAliasesDialogNotification"] = "doc:edit-aliases-dialog-notification-event"; + // for the calculation dialog + NotificationId["CalculationDialog"] = "doc:calculation-dialog-event"; + // update for an adhoc calc in a type in pill + NotificationId["TypeInPill"] = "doc:type-in-pill-event"; + // results of a validation command + NotificationId["CommandValidation"] = "doc:command-validation-event"; + // event for the groups dialog + NotificationId["UpdateCategoricalBinEditDialog"] = "doc:update-categorical-bin-edit-dialog-event"; + // for the categorical color dialog + NotificationId["CategoricalColor"] = "doc:categorical-color-event"; + // update the web categorical color dialog + NotificationId["WebCategoricalColorDialog"] = "doc:web-categorical-color-dialog-event"; + // user invoked action which requires a Data Alert Dialog + NotificationId["DataAlertDialog"] = "doc:data-alert-dialog-event"; + // event to select field(s) in the data schema + NotificationId["DataSchemaSelection"] = "doc:data-schema-selection-event"; + // event for when the data source being edited is updated + NotificationId["UpdateDataPreparation"] = "doc:update-data-preparation-event"; + // event for when the data source data is updated + NotificationId["UpdateDataSourceData"] = "doc:update-data-source-data-event"; + // event for when a client should request new data source or data source data pres models + NotificationId["DataSourceUpdateNeeded"] = "doc:data-source-update-needed-event"; + // event for getting the pres model to update file join table properties + NotificationId["TextFileProperties"] = "doc:text-file-properties-event"; + // notify changes to the state of a filter's relational model + NotificationId["FilterRelationalStateChanged"] = "doc:filter-relational-state-changed-event"; + // notify changes to the size/selection count of a relational domain + NotificationId["FilterRelationalDomainChanged"] = "doc:filter-relational-domain-changed-event"; + // notify when filter cache was requested but not found + NotificationId["FilterCacheNotFound"] = "doc:filter-cache-not-found-event"; + // Hierarchy Select model observable notification. + NotificationId["HierarchyNotification"] = "doc:hierarchy-notification-event"; + // Hierarchy selection change notifications. + NotificationId["HierarchySelection"] = "doc:hierarchy-selection-event"; + // event for the map options dialog + NotificationId["MapOptionsDialog"] = "doc:map-options-dialog-event"; + // notify the Page UI(hide/show states, layout) needs to be updated + NotificationId["UpdatePageUINotification"] = "doc:update-page-uinotification-event"; + // notify to the SceneView has been drawn. + NotificationId["SceneViewDrawnNotification"] = "doc:scene-view-drawn-notification-event"; + // The AnimationControlChange event fires when the user clicks an animation playback button: forward, stop, slow, fast, etc. + NotificationId["AnimationControlChange"] = "doc:animation-control-change-event"; + // notify the sheet has been renamed + NotificationId["RenameSheetNotification"] = "doc:rename-sheet-notification-event"; + // update the web quantitative color dialog + NotificationId["WebQuantitativeColorDialog"] = "doc:web-quantitative-color-dialog-event"; + // update the button config dialog + NotificationId["UpdateButtonConfigDialog"] = "doc:update-button-config-dialog-event"; + // event for the reference line dialog, which is only valid during web authoring + NotificationId["UpdateRefLineDialog"] = "doc:update-ref-line-dialog-event"; + // event to trigger other reference line dialogs to close + NotificationId["RefLineDialogOpening"] = "doc:ref-line-dialog-opening-event"; + // event for the close data source error dialog, which is only valid during web authoring + NotificationId["CloseDataSourceErrorDialog"] = "doc:close-data-source-error-dialog-event"; + // update the web Save Datasource dialog + NotificationId["WebSaveDatasourceDialog"] = "doc:web-save-datasource-dialog-event"; + // warning resulting from WarningMsg + NotificationId["WarningMessage"] = "doc:warning-message-event"; + // event for the table calc dialog, on web, this is only valid during web authoring + NotificationId["TableCalcDialog"] = "doc:table-calc-dialog-event"; + // user invoked action which requires Table Calc Dialog + NotificationId["TableCalcActivateDialog"] = "doc:table-calc-activate-dialog-event"; + // event for the trend line dialog + NotificationId["UpdateTrendLineEditDialog"] = "doc:update-trend-line-edit-dialog-event"; + // The table page cache has been refreshed; pages must be reloaded from the cache. + NotificationId["PageCacheRefresh"] = "doc:page-cache-refresh-event"; + // The table page cache has expired and all resources have been released. + NotificationId["PageCacheExpired"] = "doc:page-cache-expired-event"; + // All pages, identified by row/col, in the provided list have expired and should be reloaded. + NotificationId["PageCachePagesExpired"] = "doc:page-cache-pages-expired-event"; + // All pages betweem the range (inclusive) in the provided list have expired and should be reloaded. + NotificationId["PageCachePageRangeExpired"] = "doc:page-cache-page-range-expired-event"; + // Triggered when the user wants to reload an add-in instance. + NotificationId["ReloadAddIn"] = "doc:reload-add-in-event"; + // Triggered when the selected marks have changed. + NotificationId["SelectionChanged"] = "doc:selection-changed-event"; + // Triggered when the value of a parameter has changed. Emits the name and caption of the parameter + NotificationId["ParameterChanged"] = "doc:parameter-changed-event"; + // Triggered when the filters have changed. + NotificationId["FilterChanged"] = "doc:filter-changed-event"; + // Triggered when saved cluster needs to be recalculated. + NotificationId["ClusterRefitNotification"] = "doc:cluster-refit-notification-event"; + // event for the detailed error dialog + NotificationId["UpdateDetailedErrorDialog"] = "doc:update-detailed-error-dialog-event"; + // update the axis edit dialog + NotificationId["UpdateEditAxisDialog"] = "doc:update-edit-axis-dialog-event"; + // notification to launch the hybrid UI showcase + NotificationId["LaunchHybridUIShowcase"] = "doc:launch-hybrid-uishowcase-event"; + // notification of new echoed text for HybridUI showcase demo + NotificationId["HybridUIShowcaseEcho"] = "doc:hybrid-uishowcase-echo-event"; + // event for the bin dialog + NotificationId["UpdateNumericBinEditDialog"] = "doc:update-numeric-bin-edit-dialog-event"; + // Update for the rich text editor dialog + NotificationId["RichTextEditorDialog"] = "doc:rich-text-editor-dialog-event"; + // event for the sort dialog + NotificationId["UpdateSortDialog"] = "doc:update-sort-dialog-event"; + // a test event with a pres model + NotificationId["TestEventWithModel"] = "doc:test-event-with-model-event"; + // a test event without a pres model + NotificationId["TestEventWithoutModel"] = "doc:test-event-without-model-event"; + })(NotificationId = exports.NotificationId || (exports.NotificationId = {})); + + +/***/ }, +/* 88 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Api = __webpack_require__(79); + var api_utils_1 = __webpack_require__(80); + var EnumMappings_1 = __webpack_require__(89); + /** + * Class containing helper methods for converting from PresLayerPresModels to their ApiPresModels equivalents + * + * @export + * @class PresLayerToApiConverter + */ + var PresLayerToApiConverter = (function () { + function PresLayerToApiConverter() { + } + PresLayerToApiConverter.convertSheetPath = function (plSheetPath) { + var result = { + sheetName: plSheetPath.sheetName, + isDashboard: plSheetPath.isDashboard, + storyboard: plSheetPath.storyboard, + flipboardZoneID: plSheetPath.flipboardZoneId, + storyPointID: plSheetPath.storyPointId, + }; + return result; + }; + PresLayerToApiConverter.convertVisualId = function (plVisualId) { + var result = { + worksheet: plVisualId.worksheet, + dashboard: plVisualId.dashboard, + storyboard: plVisualId.storyboard, + flipboardZoneID: plVisualId.flipboardZoneId, + storyPointID: plVisualId.storyPointId, + }; + return result; + }; + PresLayerToApiConverter.convertExtensionLocator = function (plAddInLocator) { + var dashboardPath = undefined; + if (plAddInLocator.sheetPath) { + dashboardPath = PresLayerToApiConverter.convertSheetPath(plAddInLocator.sheetPath); + } + var result = { + instanceId: plAddInLocator.addInInstanceId, + dashboardPath: dashboardPath + }; + return result; + }; + PresLayerToApiConverter.convertDashboardInZones = function (plDashboard) { + var result = new Array(); + for (var _i = 0, _a = Object.keys(plDashboard.zones); _i < _a.length; _i++) { + var zoneKey = _a[_i]; + var zone = plDashboard.zones[zoneKey]; + var apiZone = { + name: zone.zoneCommon.name, + zoneId: zone.zoneId, + zoneType: EnumMappings_1.PresLayerToApiEnumMappings.zoneType.convert(zone.zoneCommon.zoneType), + height: zone.zoneCommon.h, + width: zone.zoneCommon.w, + x: zone.zoneCommon.x, + y: zone.zoneCommon.y + }; + result.push(apiZone); + } + return result; + }; + PresLayerToApiConverter.convertDashboardInfo = function (plDashboardInfo) { + var result = { + zones: PresLayerToApiConverter.convertDashboardInZones(plDashboardInfo.dashboardPresModel), + name: plDashboardInfo.dashboardPresModel.sheetPath.sheetName, + extensionZoneId: plDashboardInfo.zoneId, + size: plDashboardInfo.dashboardPresModel.viewportSize + }; + return result; + }; + PresLayerToApiConverter.convertExtensionInstance = function (plAddInInstance) { + var result = { + url: plAddInInstance.addInRegistrationPresModel.url, + locator: PresLayerToApiConverter.convertExtensionLocator(plAddInInstance.addInLocatorPresModel) + }; + return result; + }; + PresLayerToApiConverter.convertExtensionEnivrionment = function (plAddInEnvironment) { + var result = { + extensionContext: EnumMappings_1.PresLayerToApiEnumMappings.extensionContext.convert(plAddInEnvironment.addInContext), + extensionMode: EnumMappings_1.PresLayerToApiEnumMappings.extensionMode.convert(plAddInEnvironment.addInMode), + extensionLocale: plAddInEnvironment.addInLocale, + extensionLanguage: plAddInEnvironment.addInLanguage, + tableauVersion: plAddInEnvironment.tableauVersion, + operatingSystem: plAddInEnvironment.operatingSystem, + apiVersion: plAddInEnvironment.apiVersion + }; + return result; + }; + PresLayerToApiConverter.convertExtensionSettingsInfo = function (plAddInSettings) { + var result = { + // addInSettings is undefined during bootstrap initialization + settingsValues: plAddInSettings.addInSettings || {} + }; + return result; + }; + PresLayerToApiConverter.convertExtensionBootstrapInfo = function (plBootstrapInfo) { + var result = { + extensionDashboardInfo: PresLayerToApiConverter.convertDashboardInfo(plBootstrapInfo.addInDashboardInfoPresModel), + extensionEnvironment: PresLayerToApiConverter.convertExtensionEnivrionment(plBootstrapInfo.addInEnvironmentPresModel), + extensionInstance: PresLayerToApiConverter.convertExtensionInstance(plBootstrapInfo.addInInstancePresModel), + extensionSettingsInfo: PresLayerToApiConverter.convertExtensionSettingsInfo(plBootstrapInfo.addInSettingsInfo) + }; + return result; + }; + PresLayerToApiConverter.convertFieldCaptionPair = function (plFieldCaptionPair) { + return plFieldCaptionPair.fn; + }; + PresLayerToApiConverter.convertFilterEvent = function (plFilterEvent) { + var result = { + visualId: PresLayerToApiConverter.convertVisualId(plFilterEvent.visualIdPresModel), + fieldName: plFilterEvent.fieldCaption + }; + return result; + }; + PresLayerToApiConverter.convertDataSchema = function (dataSchema) { + var apiDataSources = {}; + api_utils_1.Param.verifyValue(dataSchema, 'dataSchema'); + api_utils_1.Param.verifyValue(dataSchema.dataSources, 'dataSchema.dataSources'); + // Convert each pres layer datasource in the schema to an Api datasource + Object.keys(dataSchema.dataSources).forEach(function (key) { + // Skip the default Parameters datasource we receive from the platform. + if (dataSchema.dataSources[key].datasource !== PresLayerToApiConverter.PARAMETERS_DB_NAME) { + apiDataSources[key] = PresLayerToApiConverter.convertDataSource(dataSchema.dataSources[key]); + } + }); + var schemaMap = PresLayerToApiConverter.convertWorksheetDataSchemaMap(dataSchema.worksheetDataSchemaMap); + var result = { + dataSources: apiDataSources, + worksheetDataSchemaMap: schemaMap, + }; + return result; + }; + PresLayerToApiConverter.convertDataSource = function (dataSource) { + var extractUpdateTime = (dataSource.extractUpdateTime === '') ? undefined : dataSource.extractUpdateTime; + var dataSourceFields = new Array(); + api_utils_1.Param.verifyValue(dataSource, 'dataSource'); + api_utils_1.Param.verifyValue(dataSource.fieldList, 'dataSchema.fieldList'); + dataSource.fieldList.forEach(function (plField) { + // If the datasource contains hierarchies or folders, the base field will contain + // a list of the fields grouped beneath it, we are interested in those. + // Tableau does not support nested folders or hierarchies, so this does not need to be recursive. + var hierarchyModel = plField; + if (hierarchyModel.columnList) { + hierarchyModel.columnList.forEach(function (field) { return dataSourceFields.push(PresLayerToApiConverter.convertField(field)); }); + } + else { + // This is a bit brittle for now, but this value is not exposed via the platform FieldType Enum. + if (plField.type !== 'field-folder' && plField.type !== 'dimension') { + dataSourceFields.push(PresLayerToApiConverter.convertField(plField)); + } + } + }); + var result = { + name: dataSource.datasourceCaption, + id: dataSource.datasource, + isExtract: (extractUpdateTime !== undefined), + extractUpdateTime: extractUpdateTime, + fields: dataSourceFields + }; + return result; + }; + PresLayerToApiConverter.convertWorksheetDataSchemaMap = function (schemaMap) { + var result = {}; + Object.keys(schemaMap).forEach(function (key) { + // We need to remove any references to the "Parameters" datasource. This is treated as a separate + // datasource by the platform, but the Extensions API accesses Parameters directly. + var cleanReferencedDataSourceList = schemaMap[key].referencedDataSourceList.filter(function (dsName) { + return dsName !== PresLayerToApiConverter.PARAMETERS_DB_NAME; + }); + var worksheetDataSourceInfo = { + primaryDataSource: schemaMap[key].primaryDatasource, + referencedDataSourceList: cleanReferencedDataSourceList + }; + result[key] = worksheetDataSourceInfo; + }); + return result; + }; + PresLayerToApiConverter.convertField = function (plField) { + var fieldColumn = plField; + var groupColumn = plField; + var aggregation = Api.FieldAggregationType.None; + var role = Api.FieldRoleType.Unknown; + var isCalculated = false; + // We expect that every FieldPresModel we get back from the command that returns FieldPresModels + // is actually an instance of the derived FieldColumnPresModel. + if (fieldColumn.aggregation && fieldColumn.fieldRole) { + aggregation = EnumMappings_1.PresLayerToApiEnumMappings.fieldAggregationType.convert(fieldColumn.aggregation); + role = EnumMappings_1.PresLayerToApiEnumMappings.fieldRoleType.convert(fieldColumn.fieldRole); + isCalculated = fieldColumn.isCalculated || false; + } + else { + throw new Error('Unexpected Internal Error: field pres model is missing expected properties.'); + } + var result = { + name: plField.description, + id: plField.name, + description: plField.userCaption, + aggregation: aggregation, + isHidden: !!(plField.isHidden), + isGenerated: plField.isGenerated, + isCalculatedField: isCalculated, + role: role, + isCombinedField: !!(groupColumn.isCombinedField) + }; + return result; + }; + PresLayerToApiConverter.convertJoinDescription = function (plJoinDescription) { + api_utils_1.Param.verifyValue(plJoinDescription, 'plJoinDescription'); + var apiTables = plJoinDescription.joinTableInfos.map(function (joinTable) { + var apiTable = { + name: joinTable.tableAlias, + id: joinTable.tableName, + customSQL: (joinTable.isCustomSql) ? joinTable.sqlQuery : undefined, + connectionClassName: joinTable.connectionClassName, + connectionId: joinTable.connectionName + }; + return apiTable; + }); + var result = { + tables: apiTables + }; + return result; + }; + PresLayerToApiConverter.convertConnectionDescrptionSummaries = function (plConnectionDescription) { + return plConnectionDescription.map(function (plSummary) { + var apiConnection = { + name: plSummary.connectionDescriptionLabel, + id: plSummary.connectionName, + type: plSummary.connectionTypeLabel, + serverURI: plSummary.connectionUri + }; + return apiConnection; + }); + }; + PresLayerToApiConverter.PARAMETERS_DB_NAME = 'Parameters'; + return PresLayerToApiConverter; + }()); + exports.PresLayerToApiConverter = PresLayerToApiConverter; + + +/***/ }, +/* 89 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var api_utils_1 = __webpack_require__(80); + var Enums = __webpack_require__(90); + /* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */ + var PresLayerToApiEnumMappings = (function () { + function PresLayerToApiEnumMappings() { + } + PresLayerToApiEnumMappings.zoneType = new api_utils_1.EnumConverter((_a = {}, + _a[Enums.ZoneType.ZT_Invalid] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_Viz] = api_internal_contract_1.DashboardObjectType.Worksheet, + _a[Enums.ZoneType.ZT_ColorLegend] = api_internal_contract_1.DashboardObjectType.Legend, + _a[Enums.ZoneType.ZT_ShapeLegend] = api_internal_contract_1.DashboardObjectType.Legend, + _a[Enums.ZoneType.ZT_SizeLegend] = api_internal_contract_1.DashboardObjectType.Legend, + _a[Enums.ZoneType.ZT_MapLegend] = api_internal_contract_1.DashboardObjectType.Legend, + _a[Enums.ZoneType.ZT_QuickFilter] = api_internal_contract_1.DashboardObjectType.QuickFilter, + _a[Enums.ZoneType.ZT_Highlighter] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_CurrPage] = api_internal_contract_1.DashboardObjectType.PageFilter, + _a[Enums.ZoneType.ZT_Empty] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_Title] = api_internal_contract_1.DashboardObjectType.Title, + _a[Enums.ZoneType.ZT_Text] = api_internal_contract_1.DashboardObjectType.Text, + _a[Enums.ZoneType.ZT_Bitmap] = api_internal_contract_1.DashboardObjectType.Image, + _a[Enums.ZoneType.ZT_Web] = api_internal_contract_1.DashboardObjectType.WebPage, + _a[Enums.ZoneType.ZT_AddIn] = api_internal_contract_1.DashboardObjectType.Extension, + _a[Enums.ZoneType.ZT_ParamCtrl] = api_internal_contract_1.DashboardObjectType.ParameterControl, + _a[Enums.ZoneType.ZT_FlipboardNav] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_Flipboard] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_LayoutBasic] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_LayoutFlow] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_LayoutFreeForm] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_End] = api_internal_contract_1.DashboardObjectType.Blank, + _a[Enums.ZoneType.ZT_Button] = api_internal_contract_1.DashboardObjectType.Blank, + _a), api_internal_contract_1.DashboardObjectType.Blank); + PresLayerToApiEnumMappings.extensionContext = new api_utils_1.EnumConverter((_b = {}, + _b[Enums.AddInContext.Unknown] = api_internal_contract_1.ExtensionContext.Unknown, + _b[Enums.AddInContext.Desktop] = api_internal_contract_1.ExtensionContext.Desktop, + _b[Enums.AddInContext.Server] = api_internal_contract_1.ExtensionContext.Server, + _b)); + PresLayerToApiEnumMappings.extensionMode = new api_utils_1.EnumConverter((_c = {}, + _c[Enums.AddInMode.Unknown] = api_internal_contract_1.ExtensionMode.Unknown, + _c[Enums.AddInMode.Authoring] = api_internal_contract_1.ExtensionMode.Authoring, + _c[Enums.AddInMode.Viewing] = api_internal_contract_1.ExtensionMode.Viewing, + _c)); + PresLayerToApiEnumMappings.dataType = new api_utils_1.EnumConverter((_d = {}, + _d[Enums.DataType.DT_BOOLEAN] = api_internal_contract_1.DataType.Bool, + _d[Enums.DataType.DT_DATE] = api_internal_contract_1.DataType.Date, + _d[Enums.DataType.DT_DATETIME] = api_internal_contract_1.DataType.DateTime, + _d[Enums.DataType.DT_INTEGER] = api_internal_contract_1.DataType.Int, + _d[Enums.DataType.DT_REAL] = api_internal_contract_1.DataType.Float, + _d[Enums.DataType.DT_STRING] = api_internal_contract_1.DataType.String, + _d[Enums.DataType.DT_SPATIAL] = api_internal_contract_1.DataType.Spatial, + _d)); + PresLayerToApiEnumMappings.fieldAggregationType = new api_utils_1.EnumConverter((_e = {}, + _e[Enums.AggType.AGG_ATTR] = api_internal_contract_1.FieldAggregationType.Attr, + _e[Enums.AggType.AGG_AVG] = api_internal_contract_1.FieldAggregationType.Avg, + _e[Enums.AggType.AGG_COUNT] = api_internal_contract_1.FieldAggregationType.Count, + _e[Enums.AggType.AGG_COUNTD] = api_internal_contract_1.FieldAggregationType.Countd, + _e[Enums.AggType.AGG_DAY] = api_internal_contract_1.FieldAggregationType.Day, + _e[Enums.AggType.AGG_END] = api_internal_contract_1.FieldAggregationType.End, + _e[Enums.AggType.AGG_HOUR] = api_internal_contract_1.FieldAggregationType.Hour, + _e[Enums.AggType.AGG_INOUT] = api_internal_contract_1.FieldAggregationType.InOut, + _e[Enums.AggType.AGG_KURTOSIS] = api_internal_contract_1.FieldAggregationType.Kurtosis, + _e[Enums.AggType.AGG_MAX] = api_internal_contract_1.FieldAggregationType.Max, + _e[Enums.AggType.AGG_MDY] = api_internal_contract_1.FieldAggregationType.Mdy, + _e[Enums.AggType.AGG_MEDIAN] = api_internal_contract_1.FieldAggregationType.Median, + _e[Enums.AggType.AGG_MIN] = api_internal_contract_1.FieldAggregationType.Min, + _e[Enums.AggType.AGG_MINUTE] = api_internal_contract_1.FieldAggregationType.Minute, + _e[Enums.AggType.AGG_MONTHYEAR] = api_internal_contract_1.FieldAggregationType.MonthYear, + _e[Enums.AggType.AGG_NONE] = api_internal_contract_1.FieldAggregationType.None, + _e[Enums.AggType.AGG_QTR] = api_internal_contract_1.FieldAggregationType.Qtr, + _e[Enums.AggType.AGG_QUART1] = api_internal_contract_1.FieldAggregationType.Quart1, + _e[Enums.AggType.AGG_QUART3] = api_internal_contract_1.FieldAggregationType.Quart3, + _e[Enums.AggType.AGG_SECOND] = api_internal_contract_1.FieldAggregationType.Second, + _e[Enums.AggType.AGG_SKEWNESS] = api_internal_contract_1.FieldAggregationType.Skewness, + _e[Enums.AggType.AGG_STDEV] = api_internal_contract_1.FieldAggregationType.Stdev, + _e[Enums.AggType.AGG_STDEVP] = api_internal_contract_1.FieldAggregationType.Stdevp, + _e[Enums.AggType.AGG_SUM] = api_internal_contract_1.FieldAggregationType.Sum, + _e[Enums.AggType.TRUNC_DAY] = api_internal_contract_1.FieldAggregationType.TruncDay, + _e[Enums.AggType.TRUNC_HOUR] = api_internal_contract_1.FieldAggregationType.TruncHour, + _e[Enums.AggType.TRUNC_MINUTE] = api_internal_contract_1.FieldAggregationType.TruncMinute, + _e[Enums.AggType.TRUNC_MONTH] = api_internal_contract_1.FieldAggregationType.TruncMonth, + _e[Enums.AggType.TRUNC_QTR] = api_internal_contract_1.FieldAggregationType.TruncQtr, + _e[Enums.AggType.TRUNC_SECOND] = api_internal_contract_1.FieldAggregationType.TruncSecond, + _e[Enums.AggType.TRUNC_WEEK] = api_internal_contract_1.FieldAggregationType.TruncWeek, + _e[Enums.AggType.TRUNC_YEAR] = api_internal_contract_1.FieldAggregationType.TruncYear, + _e[Enums.AggType.AGG_USER] = api_internal_contract_1.FieldAggregationType.User, + _e[Enums.AggType.AGG_VAR] = api_internal_contract_1.FieldAggregationType.Var, + _e[Enums.AggType.AGG_VARP] = api_internal_contract_1.FieldAggregationType.Varp, + _e[Enums.AggType.AGG_WEEK] = api_internal_contract_1.FieldAggregationType.Week, + _e[Enums.AggType.AGG_WEEKDAY] = api_internal_contract_1.FieldAggregationType.Weekday, + _e[Enums.AggType.AGG_YEAR] = api_internal_contract_1.FieldAggregationType.Year, + _e)); + PresLayerToApiEnumMappings.fieldRoleType = new api_utils_1.EnumConverter((_f = {}, + _f[Enums.FieldRole.ROLE_DIMENSION] = api_internal_contract_1.FieldRoleType.Dimension, + _f[Enums.FieldRole.ROLE_MEASURE] = api_internal_contract_1.FieldRoleType.Measure, + _f)); + PresLayerToApiEnumMappings.parameterTypesDomainType = new api_utils_1.EnumConverter((_g = {}, + _g[Enums.ParameterTypesDomainType.Domain_Any] = api_internal_contract_1.DomainRestrictionType.All, + _g[Enums.ParameterTypesDomainType.Domain_List] = api_internal_contract_1.DomainRestrictionType.List, + _g[Enums.ParameterTypesDomainType.Domain_Range] = api_internal_contract_1.DomainRestrictionType.Range, + _g)); + PresLayerToApiEnumMappings.dateStepPeriod = new api_utils_1.EnumConverter((_h = {}, + _h[Enums.DatePeriodType.PeriodYear] = api_internal_contract_1.DateStepPeriod.Years, + _h[Enums.DatePeriodType.PeriodQuarter] = api_internal_contract_1.DateStepPeriod.Quarters, + _h[Enums.DatePeriodType.PeriodMonth] = api_internal_contract_1.DateStepPeriod.Months, + _h[Enums.DatePeriodType.PeriodWeek] = api_internal_contract_1.DateStepPeriod.Weeks, + _h[Enums.DatePeriodType.PeriodDay] = api_internal_contract_1.DateStepPeriod.Days, + _h[Enums.DatePeriodType.PeriodHour] = api_internal_contract_1.DateStepPeriod.Hours, + _h[Enums.DatePeriodType.PeriodMinute] = api_internal_contract_1.DateStepPeriod.Minutes, + _h[Enums.DatePeriodType.PeriodSecond] = api_internal_contract_1.DateStepPeriod.Seconds, + _h)); + PresLayerToApiEnumMappings.dateRangeType = new api_utils_1.EnumConverter((_j = {}, + _j[Enums.FiltersRelativeDateRangeType.RangeCurrent] = api_internal_contract_1.DateRangeType.Current, + _j[Enums.FiltersRelativeDateRangeType.RangeCurrentToDate] = api_internal_contract_1.DateRangeType.ToDate, + _j[Enums.FiltersRelativeDateRangeType.RangeLast1] = api_internal_contract_1.DateRangeType.Last, + _j[Enums.FiltersRelativeDateRangeType.RangeLastN] = api_internal_contract_1.DateRangeType.LastN, + _j[Enums.FiltersRelativeDateRangeType.RangeNext1] = api_internal_contract_1.DateRangeType.Next, + _j[Enums.FiltersRelativeDateRangeType.RangeNextN] = api_internal_contract_1.DateRangeType.NextN, + _j)); + PresLayerToApiEnumMappings.filterDomainType = new api_utils_1.EnumConverter((_k = {}, + _k[Enums.FiltersDomainType.Relevant] = api_internal_contract_1.FilterDomainType.Relevant, + _k[Enums.FiltersDomainType.Database] = api_internal_contract_1.FilterDomainType.Database, + _k)); + return PresLayerToApiEnumMappings; + }()); + exports.PresLayerToApiEnumMappings = PresLayerToApiEnumMappings; + var ApiToPresLayerEnumMappings = (function () { + function ApiToPresLayerEnumMappings() { + } + ApiToPresLayerEnumMappings.filterUpdateType = new api_utils_1.EnumConverter((_a = {}, + _a[api_internal_contract_1.FilterUpdateType.Add] = Enums.FilterUpdateType.ADD, + _a[api_internal_contract_1.FilterUpdateType.All] = Enums.FilterUpdateType.ALL, + _a[api_internal_contract_1.FilterUpdateType.Replace] = Enums.FilterUpdateType.REPLACE, + _a[api_internal_contract_1.FilterUpdateType.Remove] = Enums.FilterUpdateType.REMOVE, + _a)); + ApiToPresLayerEnumMappings.nullOption = new api_utils_1.EnumConverter((_b = {}, + _b[api_internal_contract_1.FilterNullOption.AllValues] = Enums.FiltersQuantitativeIncludedValues.All, + _b[api_internal_contract_1.FilterNullOption.NonNullValues] = Enums.FiltersQuantitativeIncludedValues.NonNull, + _b[api_internal_contract_1.FilterNullOption.NullValues] = Enums.FiltersQuantitativeIncludedValues.Null, + _b)); + ApiToPresLayerEnumMappings.filterDomainType = new api_utils_1.EnumConverter((_c = {}, + _c[api_internal_contract_1.FilterDomainType.Relevant] = Enums.FiltersDomainType.Relevant, + _c[api_internal_contract_1.FilterDomainType.Database] = Enums.FiltersDomainType.Database, + _c)); + return ApiToPresLayerEnumMappings; + }()); + exports.ApiToPresLayerEnumMappings = ApiToPresLayerEnumMappings; + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _a, _b, _c; + /* tslint:enable:typedef */ + + +/***/ }, +/* 90 */ +/***/ function(module, exports) { + + "use strict"; + /* tslint:disable */ + // ----------------------------------------------------------------------------- + // + // This file is the copyrighted property of Tableau Software and is protected + // by registered patents and other applicable U.S. and international laws and + // regulations. + // + // Unlicensed use of the contents of this file is prohibited. Please refer to + // the NOTICES.txt file for further details. + // + // ----------------------------------------------------------------------------- + // WARNING: Computer generated file. Do not hand modify. + // DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/enum-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-enums.data'] + Object.defineProperty(exports, "__esModule", { value: true }); + // + var DataScaling; + (function (DataScaling) { + // + DataScaling["SCALING_NONE"] = "none"; + // + DataScaling["SCALING_STANDARDIZED"] = "standardized"; + // + DataScaling["SCALING_NORMALIZED"] = "normalized"; + })(DataScaling = exports.DataScaling || (exports.DataScaling = {})); + // + var ForecastModelType; + (function (ForecastModelType) { + // + ForecastModelType["ForecastModelTypeAutoSeason"] = "auto-season"; + // + ForecastModelType["ForecastModelTypeAuto"] = "auto"; + // + ForecastModelType["ForecastModelTypeCustom"] = "custom"; + })(ForecastModelType = exports.ForecastModelType || (exports.ForecastModelType = {})); + // + var ForecastRangeType; + (function (ForecastRangeType) { + // + ForecastRangeType["ForecastRangeTypeAuto"] = "auto"; + // + ForecastRangeType["ForecastRangeTypeNext"] = "next"; + // + ForecastRangeType["ForecastRangeTypeEndOf"] = "end-of"; + })(ForecastRangeType = exports.ForecastRangeType || (exports.ForecastRangeType = {})); + // + var ForecastStatus; + (function (ForecastStatus) { + // + ForecastStatus["FS_VALID"] = "fs-valid"; + // + ForecastStatus["FS_INVALID_DATETIME"] = "fs-invalid-datetime"; + // + ForecastStatus["FS_INVALID_RESPONSE"] = "fs-invalid-response"; + // + ForecastStatus["FS_NEED_MORE_DATA"] = "fs-need-more-data"; + // + ForecastStatus["FS_TIME_SERIES_TOO_SHORT"] = "fs-time-series-too-short"; + // + ForecastStatus["FS_TIME_SERIES_IRREGULAR"] = "fs-time-series-irregular"; + // + ForecastStatus["FS_NULL_DATETIME"] = "fs-null-datetime"; + // + ForecastStatus["FS_NULL_RESPONSE"] = "fs-null-response"; + // + ForecastStatus["FS_METADATA_INVALID"] = "fs-metadata-invalid"; + // + ForecastStatus["FS_NO_RESPONSE"] = "fs-no-response"; + // + ForecastStatus["FS_EXCESS_DATA"] = "fs-excess-data"; + // + ForecastStatus["FS_EXCESS_PARTITIONS"] = "fs-excess-partitions"; + // + ForecastStatus["FS_DIMENSION_INVALID"] = "fs-dimension-invalid"; + // + ForecastStatus["FS_TABLECALC_INVALID"] = "fs-tablecalc-invalid"; + // + ForecastStatus["FS_TIME_SERIES_TOO_IRREGULAR"] = "fs-time-series-too-irregular"; + // + ForecastStatus["FS_AGGREGATE_FILTER"] = "fs-aggregate-filter"; + // + ForecastStatus["FS_DISAGGREGATE_RESPONSE"] = "fs-disaggregate-response"; + // + ForecastStatus["FS_PERCENTAGE_INVALID"] = "fs-percentage-invalid"; + // + ForecastStatus["FS_TOTAL_INVALID"] = "fs-total-invalid"; + // + ForecastStatus["FS_EXCESS_DATETIME"] = "fs-excess-datetime"; + // + ForecastStatus["FS_DATE_AGG_INCOMPATIBLE"] = "fs-date-agg-incompatible"; + // + ForecastStatus["FS_TIME_SERIES_NOT_POSITIVE"] = "fs-time-series-not-positive"; + // + ForecastStatus["FS_REQUESTED_MODEL_INVALID"] = "fs-requested-model-invalid"; + // + ForecastStatus["FS_TOO_SHORT_FOR_SEASON"] = "fs-too-short-for-season"; + // + ForecastStatus["FS_REQUESTED_MODEL_UNSTABLE"] = "fs-requested-model-unstable"; + // + ForecastStatus["FS_UNDEFINED"] = "fs-undefined"; + })(ForecastStatus = exports.ForecastStatus || (exports.ForecastStatus = {})); + // + var StyleAttribute; + (function (StyleAttribute) { + // + StyleAttribute["saAlternateText"] = "saAlternateText"; + // + StyleAttribute["saAltMarkColor"] = "saAltMarkColor"; + // + StyleAttribute["saAspect"] = "saAspect"; + // + StyleAttribute["saAutoSubtitle"] = "saAutoSubtitle"; + // + StyleAttribute["saBackgroundColor"] = "saBackgroundColor"; + // + StyleAttribute["saBackgroundTransparency"] = "saBackgroundTransparency"; + // + StyleAttribute["saBandSize"] = "saBandSize"; + // + StyleAttribute["saBandColor"] = "saBandColor"; + // + StyleAttribute["saBandLevel"] = "saBandLevel"; + // + StyleAttribute["saBodyType"] = "saBodyType"; + // + StyleAttribute["saBorderColor"] = "saBorderColor"; + // + StyleAttribute["saBorderColorTop"] = "saBorderColorTop"; + // + StyleAttribute["saBorderColorRight"] = "saBorderColorRight"; + // + StyleAttribute["saBorderColorBottom"] = "saBorderColorBottom"; + // + StyleAttribute["saBorderColorLeft"] = "saBorderColorLeft"; + // + StyleAttribute["saBorderStyle"] = "saBorderStyle"; + // + StyleAttribute["saBorderStyleTop"] = "saBorderStyleTop"; + // + StyleAttribute["saBorderStyleRight"] = "saBorderStyleRight"; + // + StyleAttribute["saBorderStyleBottom"] = "saBorderStyleBottom"; + // + StyleAttribute["saBorderStyleLeft"] = "saBorderStyleLeft"; + // + StyleAttribute["saBorderWidth"] = "saBorderWidth"; + // + StyleAttribute["saBorderWidthTop"] = "saBorderWidthTop"; + // + StyleAttribute["saBorderWidthRight"] = "saBorderWidthRight"; + // + StyleAttribute["saBorderWidthBottom"] = "saBorderWidthBottom"; + // + StyleAttribute["saBorderWidthLeft"] = "saBorderWidthLeft"; + // + StyleAttribute["saBoxplotStyle"] = "saBoxplotStyle"; + // + StyleAttribute["saBreakOnSpecial"] = "saBreakOnSpecial"; + // + StyleAttribute["saCell"] = "saCell"; + // + StyleAttribute["saCellW"] = "saCellW"; + // + StyleAttribute["saCellH"] = "saCellH"; + // + StyleAttribute["saCellQ"] = "saCellQ"; + // + StyleAttribute["saCellQMark"] = "saCellQMark"; + // + StyleAttribute["saColor"] = "saColor"; + // + StyleAttribute["saColorMode"] = "saColorMode"; + // + StyleAttribute["saColLevels"] = "saColLevels"; + // + StyleAttribute["saColVertLevels"] = "saColVertLevels"; + // + StyleAttribute["saColHorizHeight"] = "saColHorizHeight"; + // + StyleAttribute["saColVertHeight"] = "saColVertHeight"; + // Deprecated + StyleAttribute["saColHeight"] = "saColHeight"; + // + StyleAttribute["saColWidth"] = "saColWidth"; + // + StyleAttribute["saContent"] = "saContent"; + // + StyleAttribute["saDisplayFieldLabels"] = "saDisplayFieldLabels"; + // + StyleAttribute["saDisplayHeader"] = "saDisplayHeader"; + // + StyleAttribute["saDisplayAlternateText"] = "saDisplayAlternateText"; + // + StyleAttribute["saDivLevel"] = "saDivLevel"; + // + StyleAttribute["saEnabled"] = "saEnabled"; + // + StyleAttribute["saFillAboveColor"] = "saFillAboveColor"; + // + StyleAttribute["saFillBelowColor"] = "saFillBelowColor"; + // + StyleAttribute["saFillColor"] = "saFillColor"; + // + StyleAttribute["saFogBGColor"] = "saFogBGColor"; + // + StyleAttribute["saFogDesaturationWithoutSelection"] = "saFogDesaturationWithoutSelection"; + // + StyleAttribute["saFogDesaturationWithSelection"] = "saFogDesaturationWithSelection"; + // + StyleAttribute["saFont"] = "saFont"; + // + StyleAttribute["saFontFamily"] = "saFontFamily"; + // + StyleAttribute["saFontSize"] = "saFontSize"; + // + StyleAttribute["saFontStyle"] = "saFontStyle"; + // + StyleAttribute["saFontWeight"] = "saFontWeight"; + // + StyleAttribute["saGeographicAreaType"] = "saGeographicAreaType"; + // + StyleAttribute["saHAlign"] = "saHAlign"; + // + StyleAttribute["saHaloColor"] = "saHaloColor"; + // + StyleAttribute["saHaloColorSelected"] = "saHaloColorSelected"; + // + StyleAttribute["saHasFill"] = "saHasFill"; + // + StyleAttribute["saHasHalo"] = "saHasHalo"; + // Deprecated + StyleAttribute["saHasLabel"] = "saHasLabel"; + // + StyleAttribute["saHasStroke"] = "saHasStroke"; + // + StyleAttribute["saHeight"] = "saHeight"; + // + StyleAttribute["saHeightHeader"] = "saHeightHeader"; + // + StyleAttribute["saHighlightLegend"] = "saHighlightLegend"; + // + StyleAttribute["saHnaxis"] = "saHnaxis"; + // + StyleAttribute["saHnlabel"] = "saHnlabel"; + // + StyleAttribute["saInTooltip"] = "saInTooltip"; + // + StyleAttribute["saLineEnd"] = "saLineEnd"; + // + StyleAttribute["saLineEndSize"] = "saLineEndSize"; + // + StyleAttribute["saLineInterpolation"] = "saLineInterpolation"; + // + StyleAttribute["saLineMarkerPosition"] = "saLineMarkerPosition"; + // + StyleAttribute["saLinePattern"] = "saLinePattern"; + // + StyleAttribute["saLinePatternOnly"] = "saLinePatternOnly"; + // + StyleAttribute["saLineVisibility"] = "saLineVisibility"; + // + StyleAttribute["saMap"] = "saMap"; + // + StyleAttribute["saMapStyle"] = "saMapStyle"; + // + StyleAttribute["saMargin"] = "saMargin"; + // + StyleAttribute["saMarginTop"] = "saMarginTop"; + // + StyleAttribute["saMarginRight"] = "saMarginRight"; + // + StyleAttribute["saMarginBottom"] = "saMarginBottom"; + // + StyleAttribute["saMarginLeft"] = "saMarginLeft"; + // + StyleAttribute["saMarkColor"] = "saMarkColor"; + // + StyleAttribute["saMarkTransparency"] = "saMarkTransparency"; + // + StyleAttribute["saMarkLabelsShow"] = "saMarkLabelsShow"; + // + StyleAttribute["saRunningOrderLabelsShow"] = "saRunningOrderLabelsShow"; + // + StyleAttribute["saMarkLabelsMode"] = "saMarkLabelsMode"; + // + StyleAttribute["saMarkLabelsCull"] = "saMarkLabelsCull"; + // + StyleAttribute["saMarkLabelsLineEndFirst"] = "saMarkLabelsLineEndFirst"; + // + StyleAttribute["saMarkLabelsLineEndLast"] = "saMarkLabelsLineEndLast"; + // + StyleAttribute["saMarkLabelsRangeMin"] = "saMarkLabelsRangeMin"; + // + StyleAttribute["saMarkLabelsRangeMax"] = "saMarkLabelsRangeMax"; + // + StyleAttribute["saMarkLabelsRangeScope"] = "saMarkLabelsRangeScope"; + // + StyleAttribute["saMarkLabelsRangeField"] = "saMarkLabelsRangeField"; + // + StyleAttribute["saMarkMarkersMode"] = "saMarkMarkersMode"; + // + StyleAttribute["saMaxHeight"] = "saMaxHeight"; + // + StyleAttribute["saMaxFontSize"] = "saMaxFontSize"; + // + StyleAttribute["saMaxStrokeWidth"] = "saMaxStrokeWidth"; + // + StyleAttribute["saMaxWidth"] = "saMaxWidth"; + // + StyleAttribute["saMidStrokeWidth"] = "saMidStrokeWidth"; + // + StyleAttribute["saMinHeight"] = "saMinHeight"; + // + StyleAttribute["saMinFontSize"] = "saMinFontSize"; + // + StyleAttribute["saMinLength"] = "saMinLength"; + // + StyleAttribute["saMinMapSize"] = "saMinMapSize"; + // + StyleAttribute["saMinSize"] = "saMinSize"; + // + StyleAttribute["saMinStrokeWidth"] = "saMinStrokeWidth"; + // + StyleAttribute["saMinWidth"] = "saMinWidth"; + // + StyleAttribute["saNonhighlightColor"] = "saNonhighlightColor"; + // + StyleAttribute["saOmitOnSpecial"] = "saOmitOnSpecial"; + // + StyleAttribute["saOpacity"] = "saOpacity"; + // + StyleAttribute["saOrientation"] = "saOrientation"; + // + StyleAttribute["saPadding"] = "saPadding"; + // + StyleAttribute["saPaddingTop"] = "saPaddingTop"; + // + StyleAttribute["saPaddingRight"] = "saPaddingRight"; + // + StyleAttribute["saPaddingBottom"] = "saPaddingBottom"; + // + StyleAttribute["saPaddingLeft"] = "saPaddingLeft"; + // + StyleAttribute["saPalette"] = "saPalette"; + // + StyleAttribute["saRenderFoldReversed"] = "saRenderFoldReversed"; + // + StyleAttribute["saReversePalette"] = "saReversePalette"; + // + StyleAttribute["saRounding"] = "saRounding"; + // + StyleAttribute["saRowHorizLevels"] = "saRowHorizLevels"; + // + StyleAttribute["saRowHorizWidth"] = "saRowHorizWidth"; + // + StyleAttribute["saRowLevels"] = "saRowLevels"; + // + StyleAttribute["saRowVertWidth"] = "saRowVertWidth"; + // + StyleAttribute["saSeparator"] = "saSeparator"; + // + StyleAttribute["saShape"] = "saShape"; + // Deprecated + StyleAttribute["saShowLabels"] = "saShowLabels"; + // + StyleAttribute["saSize"] = "saSize"; + // + StyleAttribute["saSizeBar"] = "saSizeBar"; + // + StyleAttribute["saSmartAutoAlignment"] = "saSmartAutoAlignment"; + // + StyleAttribute["saSpace"] = "saSpace"; + // + StyleAttribute["saStrokeColor"] = "saStrokeColor"; + // + StyleAttribute["saStrokeSize"] = "saStrokeSize"; + // + StyleAttribute["saSubtitle"] = "saSubtitle"; + // + StyleAttribute["saTextAlign"] = "saTextAlign"; + // + StyleAttribute["saTextAlignDefault"] = "saTextAlignDefault"; + // + StyleAttribute["saTextDecoration"] = "saTextDecoration"; + // + StyleAttribute["saTextIndent"] = "saTextIndent"; + // + StyleAttribute["saTextOrientation"] = "saTextOrientation"; + // + StyleAttribute["saTextFormat"] = "saTextFormat"; + // + StyleAttribute["saTickColor"] = "saTickColor"; + // + StyleAttribute["saTickLength"] = "saTickLength"; + // Deprecated + StyleAttribute["saTickSpacing"] = "saTickSpacing"; + // + StyleAttribute["saTitle"] = "saTitle"; + // + StyleAttribute["saTotalLabel"] = "saTotalLabel"; + // + StyleAttribute["saVAlign"] = "saVAlign"; + // + StyleAttribute["saVerticalAlign"] = "saVerticalAlign"; + // + StyleAttribute["saVerticalAlignDefault"] = "saVerticalAlignDefault"; + // + StyleAttribute["saVnaxis"] = "saVnaxis"; + // + StyleAttribute["saVnlabel"] = "saVnlabel"; + // + StyleAttribute["saWarnOnSpecial"] = "saWarnOnSpecial"; + // + StyleAttribute["saWashout"] = "saWashout"; + // + StyleAttribute["saWhiskerEnd"] = "saWhiskerEnd"; + // + StyleAttribute["saWhiskerStrokeColor"] = "saWhiskerStrokeColor"; + // + StyleAttribute["saWhiskerStrokeSize"] = "saWhiskerStrokeSize"; + // + StyleAttribute["saWidth"] = "saWidth"; + // + StyleAttribute["saWidthHeader"] = "saWidthHeader"; + // + StyleAttribute["saWrap"] = "saWrap"; + // + StyleAttribute["saZoom"] = "saZoom"; + // Special attributes used for matching + StyleAttribute["saNone"] = "saNone"; + // Special attributes used for matching + StyleAttribute["saAny"] = "saAny"; + })(StyleAttribute = exports.StyleAttribute || (exports.StyleAttribute = {})); + // lowest bit of enum value denotes two-tone styles; newly added styles should follow this pattern. + var BoxplotStyle; + (function (BoxplotStyle) { + // mask for checking if a style is two-tone + BoxplotStyle["BoxplotStyleTwoTone"] = "two-tone"; + // + BoxplotStyle["BoxplotStyleModern"] = "modern"; + // + BoxplotStyle["BoxplotStyleGlass"] = "glass"; + // + BoxplotStyle["BoxplotStyleClassic"] = "classic"; + // + BoxplotStyle["BoxplotStyleClassicTwoTone"] = "classic-two-tone"; + })(BoxplotStyle = exports.BoxplotStyle || (exports.BoxplotStyle = {})); + // used for boxplots and prediction band whiskers + var WhiskerEnd; + (function (WhiskerEnd) { + // + WhiskerEnd["WhiskerEndNone"] = "none"; + // + WhiskerEnd["WhiskerEndSmall"] = "small"; + // + WhiskerEnd["WhiskerEndLarge"] = "large"; + })(WhiskerEnd = exports.WhiskerEnd || (exports.WhiskerEnd = {})); + // + var StyleElement; + (function (StyleElement) { + // + StyleElement["elementAxis"] = "elementAxis"; + // + StyleElement["elementCell"] = "elementCell"; + // + StyleElement["elementDatalabel"] = "elementDatalabel"; + // + StyleElement["elementDropspot"] = "elementDropspot"; + // + StyleElement["elementHeader"] = "elementHeader"; + // + StyleElement["elementFieldLabel"] = "elementFieldLabel"; + // + StyleElement["elementFieldLabelDecoration"] = "elementFieldLabelDecoration"; + // + StyleElement["elementFieldLabelSpanner"] = "elementFieldLabelSpanner"; + // + StyleElement["elementLabel"] = "elementLabel"; + // + StyleElement["elementMark"] = "elementMark"; + // + StyleElement["elementPane"] = "elementPane"; + // + StyleElement["elementTable"] = "elementTable"; + // + StyleElement["elementWorksheet"] = "elementWorksheet"; + // + StyleElement["elementBasesheet"] = "elementBasesheet"; + // + StyleElement["elementDashboard"] = "elementDashboard"; + // + StyleElement["elementStoryboard"] = "elementStoryboard"; + // + StyleElement["elementCaption"] = "elementCaption"; + // + StyleElement["elementDropline"] = "elementDropline"; + // + StyleElement["elementRefline"] = "elementRefline"; + // + StyleElement["elementRefBand"] = "elementRefBand"; + // + StyleElement["elementRefBoxplot"] = "elementRefBoxplot"; + // + StyleElement["elementGridline"] = "elementGridline"; + // + StyleElement["elementZeroline"] = "elementZeroline"; + // + StyleElement["elementTrendline"] = "elementTrendline"; + // + StyleElement["elementTableDiv"] = "elementTableDiv"; + // + StyleElement["elementHeaderDiv"] = "elementHeaderDiv"; + // + StyleElement["elementMappedImage"] = "elementMappedImage"; + // + StyleElement["elementAction"] = "elementAction"; + // + StyleElement["elementTitle"] = "elementTitle"; + // + StyleElement["elementLegend"] = "elementLegend"; + // + StyleElement["elementLegendTitle"] = "elementLegendTitle"; + // + StyleElement["elementLegendTitleText"] = "elementLegendTitleText"; + // + StyleElement["elementAxisTitle"] = "elementAxisTitle"; + // + StyleElement["elementAnnotation"] = "elementAnnotation"; + // + StyleElement["elementDashTitle"] = "elementDashTitle"; + // + StyleElement["elementDashSubtitle"] = "elementDashSubtitle"; + // + StyleElement["elementDashText"] = "elementDashText"; + // + StyleElement["elementDashZone"] = "elementDashZone"; + // + StyleElement["elementDashContainer"] = "elementDashContainer"; + // + StyleElement["elementScrollbar"] = "elementScrollbar"; + // Static on/off map layers + StyleElement["elementMapLayer"] = "elementMapLayer"; + // Contains washout + StyleElement["elementMap"] = "elementMap"; + // Initially for UrbanMapping/Claritas data + StyleElement["elementMapDataLayer"] = "elementMapDataLayer"; + // + StyleElement["elementQuickFilter"] = "elementQuickFilter"; + // + StyleElement["elementQuickFilterTitle"] = "elementQuickFilterTitle"; + // + StyleElement["elementParameterCtrl"] = "elementParameterCtrl"; + // + StyleElement["elementParameterCtrlTitle"] = "elementParameterCtrlTitle"; + // + StyleElement["elementPageCardTitle"] = "elementPageCardTitle"; + // + StyleElement["elementStoryDescription"] = "elementStoryDescription"; + // + StyleElement["elementStoryPointCaption"] = "elementStoryPointCaption"; + // + StyleElement["elementStoryTitle"] = "elementStoryTitle"; + // + StyleElement["elementTooltip"] = "elementTooltip"; + // + StyleElement["elementAll"] = "elementAll"; + // + StyleElement["elementPageCardBody"] = "elementPageCardBody"; + // + StyleElement["elementDataHighlighter"] = "elementDataHighlighter"; + // + StyleElement["elementDataHighlighterTitle"] = "elementDataHighlighterTitle"; + // Special elements used for matching and organization + StyleElement["elementNone"] = "elementNone"; + // Special elements used for matching and organization + StyleElement["elementAny"] = "elementAny"; + // Special elements used for matching and organization + StyleElement["elementRoot"] = "elementRoot"; + })(StyleElement = exports.StyleElement || (exports.StyleElement = {})); + // Do not mess with these values. They are sometimes used as array indexes/bounds + var StyleDataClass; + (function (StyleDataClass) { + // + StyleDataClass["dcNormal"] = "dcNormal"; + // + StyleDataClass["dcTotal"] = "dcTotal"; + // + StyleDataClass["dcSubtotal"] = "dcSubtotal"; + // + StyleDataClass["dcCOUNT"] = "dcCOUNT"; + })(StyleDataClass = exports.StyleDataClass || (exports.StyleDataClass = {})); + // + var StyleFieldScope; + (function (StyleFieldScope) { + // + StyleFieldScope["fsNone"] = "fsNone"; + // + StyleFieldScope["fsRows"] = "fsRows"; + // + StyleFieldScope["fsCols"] = "fsCols"; + })(StyleFieldScope = exports.StyleFieldScope || (exports.StyleFieldScope = {})); + // + var StyleSwatch; + (function (StyleSwatch) { + // + StyleSwatch["ssUnspecified"] = "ssUnspecified"; + // + StyleSwatch["ssLight"] = "ssLight"; + // + StyleSwatch["ssDark"] = "ssDark"; + })(StyleSwatch = exports.StyleSwatch || (exports.StyleSwatch = {})); + // + var TableauFontStyle; + (function (TableauFontStyle) { + // + TableauFontStyle["NormalStyle"] = "font-style-normal"; + // + TableauFontStyle["Italic"] = "font-style-italic"; + })(TableauFontStyle = exports.TableauFontStyle || (exports.TableauFontStyle = {})); + // Unsupported for Betsy + var TextDecoration; + (function (TextDecoration) { + // + TextDecoration["NoDecoration"] = "text-decoration-none"; + // + TextDecoration["Underline"] = "text-decoration-underline"; + // not yet supported + TextDecoration["Overline"] = "text-decoration-overline"; + // + TextDecoration["Strikethrough"] = "text-decoration-strikethrough"; + })(TextDecoration = exports.TextDecoration || (exports.TextDecoration = {})); + // + var FontWeight; + (function (FontWeight) { + // + FontWeight["NormalWeight"] = "font-weight-normal"; + // + FontWeight["Bold"] = "font-weight-bold"; + })(FontWeight = exports.FontWeight || (exports.FontWeight = {})); + // + var TextOrient; + (function (TextOrient) { + // + TextOrient["TO_Auto"] = "text-orient-auto"; + // + TextOrient["TO_Horz"] = "text-orient-horizontal"; + // + TextOrient["TO_VertUp"] = "text-orient-vertical-up"; + // + TextOrient["TO_VertDown"] = "text-orient-vertical-down"; + })(TextOrient = exports.TextOrient || (exports.TextOrient = {})); + // + var TextAlign; + (function (TextAlign) { + // + TextAlign["TA_Start"] = "text-align-start"; + // + TextAlign["TA_Center"] = "text-align-center"; + // + TextAlign["TA_End"] = "text-align-end"; + })(TextAlign = exports.TextAlign || (exports.TextAlign = {})); + // + var TextWrapMode; + (function (TextWrapMode) { + // + TextWrapMode["TextWrapOff"] = "text-wrap-off"; + // + TextWrapMode["TextWrapTruncate"] = "text-wrap-truncate"; + // + TextWrapMode["TextWrapOn"] = "text-wrap-on"; + // + TextWrapMode["TextWrapAuto"] = "text-wrap-auto"; + })(TextWrapMode = exports.TextWrapMode || (exports.TextWrapMode = {})); + // + var TextWholeLineMode; + (function (TextWholeLineMode) { + // + TextWholeLineMode["TextWholeLineOff"] = "text-whole-line-off"; + // + TextWholeLineMode["TextWholeLineOn"] = "text-whole-line-on"; + // + TextWholeLineMode["TextWholeLineAuto"] = "text-whole-line-auto"; + })(TextWholeLineMode = exports.TextWholeLineMode || (exports.TextWholeLineMode = {})); + // + var TextBreakMode; + (function (TextBreakMode) { + // + TextBreakMode["TextBreakWhitespaceOnly"] = "text-break-ws-only"; + // + TextBreakMode["TextBreakAuto"] = "text-break-auto"; + })(TextBreakMode = exports.TextBreakMode || (exports.TextBreakMode = {})); + // type of aggregation + var AggType; + (function (AggType) { + // + AggType["AGG_SUM"] = "sum"; + // + AggType["AGG_AVG"] = "average"; + // + AggType["AGG_MIN"] = "min"; + // + AggType["AGG_MAX"] = "max"; + // + AggType["AGG_STDEV"] = "std-dev"; + // + AggType["AGG_STDEVP"] = "std-dev-p"; + // + AggType["AGG_VAR"] = "var"; + // + AggType["AGG_VARP"] = "var-p"; + // + AggType["AGG_COUNT"] = "count"; + // + AggType["AGG_COUNTD"] = "count-d"; + // + AggType["AGG_MEDIAN"] = "median"; + // + AggType["AGG_ATTR"] = "attr"; + // + AggType["AGG_NONE"] = "none"; + // + AggType["AGG_PERCENTILE"] = "percentile"; + // + AggType["AGG_YEAR"] = "year"; + // + AggType["AGG_QTR"] = "qtr"; + // + AggType["AGG_MONTH"] = "month"; + // + AggType["AGG_DAY"] = "day"; + // + AggType["AGG_HOUR"] = "hour"; + // + AggType["AGG_MINUTE"] = "minute"; + // + AggType["AGG_SECOND"] = "second"; + // + AggType["AGG_WEEK"] = "week"; + // + AggType["AGG_WEEKDAY"] = "weekday"; + // + AggType["AGG_MONTHYEAR"] = "month-year"; + // + AggType["AGG_MDY"] = "mdy"; + // + AggType["AGG_END"] = "end"; + // + AggType["TRUNC_YEAR"] = "trunc-year"; + // + AggType["TRUNC_QTR"] = "trunc-qtr"; + // + AggType["TRUNC_MONTH"] = "trunc-month"; + // + AggType["TRUNC_WEEK"] = "trunc-week"; + // + AggType["TRUNC_DAY"] = "trunc-day"; + // + AggType["TRUNC_HOUR"] = "trunc-hour"; + // + AggType["TRUNC_MINUTE"] = "trunc-minute"; + // + AggType["TRUNC_SECOND"] = "trunc-second"; + // + AggType["AGG_QUART1"] = "quart1"; + // + AggType["AGG_QUART3"] = "quart3"; + // + AggType["AGG_SKEWNESS"] = "skewness"; + // + AggType["AGG_KURTOSIS"] = "kurtosis"; + // + AggType["AGG_INOUT"] = "in-out"; + // + AggType["AGG_SUM_XSQR"] = "sum-xsqr"; + // + AggType["AGG_USER"] = "user"; + // + AggType["AGG_COLLECT"] = "collect"; + // + AggType["AGG_COVAR"] = "covar"; + // + AggType["AGG_COVARP"] = "covarp"; + // + AggType["AGG_CORR"] = "corr"; + })(AggType = exports.AggType || (exports.AggType = {})); + // DataValueFormatter::DataTypeEncodings has hardcoded values corresponding to following enum members. So any changes here should be done there too + var DataType; + (function (DataType) { + // + DataType["DT_INTEGER"] = "integer"; + // + DataType["DT_REAL"] = "real"; + // + DataType["DT_STRING"] = "cstring"; + // + DataType["DT_DATETIME"] = "datetime"; + // + DataType["DT_BOOLEAN"] = "boolean"; + // + DataType["DT_DATE"] = "date"; + // + DataType["DT_TUPLE"] = "tuple"; + // + DataType["DT_SPATIAL"] = "spatial"; + // + DataType["DT_UNKNOWN"] = "unknown"; + // + DataType["DT_BINARY"] = "binary"; + // + DataType["DT_TIME"] = "time"; + })(DataType = exports.DataType || (exports.DataType = {})); + // + var DatePeriodType; + (function (DatePeriodType) { + // + DatePeriodType["PeriodYear"] = "year"; + // + DatePeriodType["PeriodQuarter"] = "quarter"; + // + DatePeriodType["PeriodMonth"] = "month"; + // + DatePeriodType["PeriodWeek"] = "week"; + // + DatePeriodType["PeriodDay"] = "day"; + // + DatePeriodType["PeriodHour"] = "hour"; + // + DatePeriodType["PeriodMinute"] = "minute"; + // + DatePeriodType["PeriodSecond"] = "second"; + })(DatePeriodType = exports.DatePeriodType || (exports.DatePeriodType = {})); + // Format prepended to format strings to specify type + var FormatCode; + (function (FormatCode) { + // + FormatCode["AutoFormat"] = "auto-format"; + // + FormatCode["SystemLongDate"] = "system-long-date"; + // + FormatCode["SystemShortDate"] = "system-short-date"; + // + FormatCode["SystemNumber"] = "system-number"; + // + FormatCode["SystemCurrency"] = "system-currency"; + // + FormatCode["SystemTime"] = "system-time"; + // + FormatCode["Custom"] = "custom"; + // + FormatCode["CustomICU"] = "custom-icu"; + // + FormatCode["CustomNumber"] = "custom-number"; + // + FormatCode["CustomCurrency"] = "custom-currency"; + // + FormatCode["CustomScientific"] = "custom-scientific"; + // + FormatCode["CustomPercentage"] = "custom-percentage"; + })(FormatCode = exports.FormatCode || (exports.FormatCode = {})); + // Units specified in a format string + var UnitsFormatEnum; + (function (UnitsFormatEnum) { + // + UnitsFormatEnum["UnitsFmtNone"] = "units-none"; + // + UnitsFormatEnum["UnitsFmtThousands"] = "units-thousands"; + // + UnitsFormatEnum["UnitsFmtMillions"] = "units-millions"; + // + UnitsFormatEnum["UnitsFmtBillionsEnglish"] = "units-billions-english"; + // + UnitsFormatEnum["UnitsFmtBillionsStandard"] = "units-billions-standard"; + })(UnitsFormatEnum = exports.UnitsFormatEnum || (exports.UnitsFormatEnum = {})); + // + var ForecastColumnType; + (function (ForecastColumnType) { + // + ForecastColumnType["FORECAST_NONE"] = "none"; + // + ForecastColumnType["FORECAST_VALUE"] = "value"; + // + ForecastColumnType["FORECAST_INDICATOR"] = "indicator"; + // + ForecastColumnType["FORECAST_PRECISION"] = "precision"; + // + ForecastColumnType["FORECAST_QUALITY"] = "quality"; + // + ForecastColumnType["FORECAST_FIT_TREND"] = "fit_trend"; + // + ForecastColumnType["FORECAST_PRECISION_PERCENT"] = "precision_percent"; + // + ForecastColumnType["FORECAST_PREDICTION_INTERVAL_UPPER"] = "prediction_upper"; + // + ForecastColumnType["FORECAST_PREDICTION_INTERVAL_LOWER"] = "prediction_lower"; + })(ForecastColumnType = exports.ForecastColumnType || (exports.ForecastColumnType = {})); + // + var MarkMarkersMode; + (function (MarkMarkersMode) { + // + MarkMarkersMode["MMM_Auto"] = "mmm-auto"; + // + MarkMarkersMode["MMM_All"] = "mmm_all"; + // + MarkMarkersMode["MMM_None"] = "mmm_none"; + // + MarkMarkersMode["MMM_Default"] = "mmm_default"; + })(MarkMarkersMode = exports.MarkMarkersMode || (exports.MarkMarkersMode = {})); + // + var PercentMode; + (function (PercentMode) { + // + PercentMode["PERCENT_CELL_IN_PANE"] = "cell-in-pane"; + // + PercentMode["PERCENT_ROW_IN_PANE"] = "row-in-pane"; + // + PercentMode["PERCENT_COLUMN_IN_PANE"] = "column-in-pane"; + // + PercentMode["PERCENT_PANE"] = "pane"; + // + PercentMode["PERCENT_ROW"] = "row"; + // + PercentMode["PERCENT_COLUMN"] = "column"; + // + PercentMode["PERCENT_TABLE"] = "table"; + })(PercentMode = exports.PercentMode || (exports.PercentMode = {})); + // + var SpecialValuesMode; + (function (SpecialValuesMode) { + // + SpecialValuesMode["SPECIAL_VALUES_HIDE_AND_WARN"] = "hide-and-warn"; + // + SpecialValuesMode["SPECIAL_VALUES_HIDE"] = "hide"; + // + SpecialValuesMode["SPECIAL_VALUES_HIDE_BREAK_LINES"] = "hide-break-lines"; + // + SpecialValuesMode["SPECIAL_VALUES_SHOW"] = "show"; + })(SpecialValuesMode = exports.SpecialValuesMode || (exports.SpecialValuesMode = {})); + // + var LayoutType; + (function (LayoutType) { + // + LayoutType["LAYOUT_CARTESIAN"] = "cartesian"; + // + LayoutType["LAYOUT_DEFAULT"] = "default"; + })(LayoutType = exports.LayoutType || (exports.LayoutType = {})); + // + var ShelfType; + (function (ShelfType) { + // + ShelfType["ST_NONE"] = "none-shelf"; + // + ShelfType["ST_COLUMNS_SHELF"] = "columns-shelf"; + // + ShelfType["ST_ROWS_SHELF"] = "rows-shelf"; + // + ShelfType["ST_PAGES_SHELF"] = "pages-shelf"; + // + ShelfType["ST_FILTER_SHELF"] = "filter-shelf"; + // + ShelfType["ST_IMAGE_SHELF"] = "image-shelf"; + // + ShelfType["ST_MEASURES_SHELF"] = "measures-shelf"; + // + ShelfType["ST_SHOWME_SHELF"] = "show-me-shelf"; + // + ShelfType["ST_ENCODING_SHELF"] = "encoding-shelf"; + // + ShelfType["ST_CLUSTER_SHELF"] = "cluster-shelf"; + // + ShelfType["ST_GEOMETRY_SHELF"] = "geometry-shelf"; + // + ShelfType["ST_END"] = "end-shelf"; + // + ShelfType["ST_FINAL"] = "final-shelf"; + })(ShelfType = exports.ShelfType || (exports.ShelfType = {})); + // + var RestrictType; + (function (RestrictType) { + // + RestrictType["RT_INTERSECT"] = "rt-intersection"; + // + RestrictType["RT_UNION"] = "rt-union"; + })(RestrictType = exports.RestrictType || (exports.RestrictType = {})); + // + var TooltipMode; + (function (TooltipMode) { + // + TooltipMode["TM_NONE"] = "none"; + // + TooltipMode["TM_STICKY"] = "sticky"; + // + TooltipMode["TM_SMOOTH"] = "smooth"; + })(TooltipMode = exports.TooltipMode || (exports.TooltipMode = {})); + // + var ColumnGroups; + (function (ColumnGroups) { + // 0x01 + ColumnGroups["COLS_IN_OUTPUT"] = "cols-in-output"; + // 0x02 + ColumnGroups["COLS_IN_FILTER_SHELF"] = "cols-in-filter-shelf"; + // 0x04 + ColumnGroups["COLS_REF_BY_FILTERS"] = "cols-ref-by-filters"; + // 0x08 + ColumnGroups["COLS_REF_BY_OMEASURES"] = "cols-ref-by-omeasures"; + // 0x10 + ColumnGroups["COLS_REF_BY_JOIN_LOD"] = "cols-ref-by-join-lod"; + // 0x20 + ColumnGroups["COLS_HIDDEN"] = "cols-hidden"; + // 0x40 + ColumnGroups["COLS_REF_BY_SORTS"] = "cols-ref-by-sorts"; + // + ColumnGroups["COLS_REF_BY_FILTERS_OR_SORTS"] = "cols-ref-by-filters-or-sorts"; + // + ColumnGroups["COLS_ON_SHELVES"] = "cols-on-shelves"; + // + ColumnGroups["COLS_ALL"] = "cols-all"; + })(ColumnGroups = exports.ColumnGroups || (exports.ColumnGroups = {})); + // + var ButtonsOption; + (function (ButtonsOption) { + // + ButtonsOption["BO_HIDE"] = "buttons-hide"; + })(ButtonsOption = exports.ButtonsOption || (exports.ButtonsOption = {})); + // + var SelectionRelaxationOption; + (function (SelectionRelaxationOption) { + // + SelectionRelaxationOption["SRO_ALLOW"] = "selection-relaxation-allow"; + // + SelectionRelaxationOption["SRO_DISALLOW"] = "selection-relaxation-disallow"; + })(SelectionRelaxationOption = exports.SelectionRelaxationOption || (exports.SelectionRelaxationOption = {})); + // + var EncodingType; + (function (EncodingType) { + // a text encoding + EncodingType["ET_TEXT"] = "text-encoding"; + // a color encoding + EncodingType["ET_COLOR"] = "color-encoding"; + // a size encoding + EncodingType["ET_SIZE"] = "size-encoding"; + // a shape encoding + EncodingType["ET_SHAPE"] = "shape-encoding"; + // an image encoding + EncodingType["ET_IMAGE"] = "image-encoding"; + // a sort (path) encoding (currently only for line or polygon charts) + EncodingType["ET_SORT"] = "sort-encoding"; + // a wedge size (angle) encoding (currently only for pie charts) + EncodingType["ET_WEDGESIZE"] = "wedge-size-encoding"; + // a geometry encoding + EncodingType["ET_GEOMETRY"] = "geometry-encoding"; + // a level of detail encoding + EncodingType["ET_LOD"] = "level-of-detail-encoding"; + // encoding used for the data highlighter/legend mechanism + EncodingType["ET_HIGHLIGHT"] = "highlight-encoding"; + // a tooltip encoding + EncodingType["ET_TOOLTIP"] = "tooltip-encoding"; + // a temporary label placed above marks for the table calc dialog + EncodingType["ET_RUNNINGORDER"] = "runningorder-encoding"; + // the number of encodings, this is invalid input for an encoding presentation model + EncodingType["NUM_ENCODINGS"] = "num-encodings"; + // an invalid encoding + EncodingType["ET_INVALID"] = "invalid-encoding"; + })(EncodingType = exports.EncodingType || (exports.EncodingType = {})); + // Enumeration of valid horizontal alignments. + var LabelHAlignment; + (function (LabelHAlignment) { + // + LabelHAlignment["LHA_Left"] = "h-align-left"; + // + LabelHAlignment["LHA_Center"] = "h-align-center"; + // + LabelHAlignment["LHA_Right"] = "h-align-right"; + // + LabelHAlignment["LHA_Automatic"] = "h-align-auto"; + })(LabelHAlignment = exports.LabelHAlignment || (exports.LabelHAlignment = {})); + // Enumeration of valid vertical alignments. + var LabelVAlignment; + (function (LabelVAlignment) { + // + LabelVAlignment["LVA_Bottom"] = "v-align-bottom"; + // + LabelVAlignment["LVA_Center"] = "v-align-center"; + // + LabelVAlignment["LVA_Top"] = "v-align-top"; + // + LabelVAlignment["LVA_Automatic"] = "v-align-auto"; + })(LabelVAlignment = exports.LabelVAlignment || (exports.LabelVAlignment = {})); + // Enumeration of valid label positions. + var LabelPosition; + (function (LabelPosition) { + // Position each text run relative to the center of the original bbox. Use the original bbox as the height and width of the text mark. Used for non-stacked OO text marks. + LabelPosition["CenterInOriginalBbox"] = "label-position-center-in-original-box"; + // Position each text run relative to the bottom left corner of the measured bbox. Use the measured bbox as the width and height of the label. Used for labels + LabelPosition["OriginAtLowerLeft"] = "label-position-origin-at-lower-left"; + // Position each text run relative to the center of the measured bbox. Use the measured bbox as the width and height of the text mark. Used for most text marks. + LabelPosition["OriginAtCenter"] = "label-position-origin-at-center"; + })(LabelPosition = exports.LabelPosition || (exports.LabelPosition = {})); + // Enumeration of ways to use color. Values can be or'ed together to make a mask for allowed options + var ColorMode; + (function (ColorMode) { + // Color user specified + ColorMode["CLRM_User"] = "clrm-user"; + // Color selected automatically + ColorMode["CLRM_Auto"] = "clrm-auto"; + // Color matches mark color + ColorMode["CLRM_Match"] = "clrm-match"; + // No color (transparent or not drawn) + ColorMode["CLRM_None"] = "clrm-none"; + })(ColorMode = exports.ColorMode || (exports.ColorMode = {})); + // + var MarkLabelsMode; + (function (MarkLabelsMode) { + // + MarkLabelsMode["MLM_All"] = "mlm-all"; + // + MarkLabelsMode["MLM_Selection"] = "mlm-selection"; + // + MarkLabelsMode["MLM_Highlight"] = "mlm-highlight"; + // + MarkLabelsMode["MLM_LineEnds"] = "mlm-line-ends"; + // min/max setting + MarkLabelsMode["MLM_Range"] = "mlm-range"; + // most recent (only relevant when date field is in play) + MarkLabelsMode["MLM_MostRecent"] = "mlm-most-recent"; + // ...this is " virtual " (runtime only, not saved, not shown as a user setting + MarkLabelsMode["MLM_MultipleValues"] = "mlm-multiple-values"; + // + MarkLabelsMode["MLM_Default"] = "mlm-default"; + })(MarkLabelsMode = exports.MarkLabelsMode || (exports.MarkLabelsMode = {})); + // + var MarkLabelsScope; + (function (MarkLabelsScope) { + // + MarkLabelsScope["MLS_Table"] = "mls-table"; + // + MarkLabelsScope["MLS_Pane"] = "mls-pane"; + // + MarkLabelsScope["MLS_Cell"] = "mls-cell"; + // + MarkLabelsScope["MLS_MultiMark"] = "mls-multimark"; + // ...this is " virtual " (runtime only, not saved, not shown as a user setting) + MarkLabelsScope["MLS_MultipleValues"] = "mls-multiple-values"; + // + MarkLabelsScope["MLS_Default"] = "mls-default"; + })(MarkLabelsScope = exports.MarkLabelsScope || (exports.MarkLabelsScope = {})); + // + var MarkLabelsVisibility; + (function (MarkLabelsVisibility) { + // + MarkLabelsVisibility["MLV_Hidden"] = "mlv-hidden"; + // + MarkLabelsVisibility["MLV_Visible"] = "mlv-visible"; + // + MarkLabelsVisibility["MLV_UseCurrent"] = "mlv-use-current"; + })(MarkLabelsVisibility = exports.MarkLabelsVisibility || (exports.MarkLabelsVisibility = {})); + // + var StackingMode; + (function (StackingMode) { + // + StackingMode["StackingOff"] = "off"; + // + StackingMode["StackingOn"] = "on"; + // + StackingMode["StackingAuto"] = "auto"; + })(StackingMode = exports.StackingMode || (exports.StackingMode = {})); + // + var MarkAlignment; + (function (MarkAlignment) { + // + MarkAlignment["MarkAlignmentLeft"] = "mark-alignment-left"; + // + MarkAlignment["MarkAlignmentRight"] = "mark-alignment-right"; + // + MarkAlignment["MarkAlignmentCenter"] = "mark-alignment-center"; + })(MarkAlignment = exports.MarkAlignment || (exports.MarkAlignment = {})); + // + var PaneLabelComposition; + (function (PaneLabelComposition) { + // + PaneLabelComposition["PLC_None"] = "pane-label-composition-none"; + // + PaneLabelComposition["PLC_Mixed"] = "pane-label-composition-mixed"; + // + PaneLabelComposition["PLC_All"] = "pane-label-composition-all"; + })(PaneLabelComposition = exports.PaneLabelComposition || (exports.PaneLabelComposition = {})); + // The user-specified mark type on the Marks Card + var PrimitiveType; + (function (PrimitiveType) { + // + PrimitiveType["PT_AUTOMATIC"] = "automatic"; + // + PrimitiveType["PT_TEXT"] = "text"; + // + PrimitiveType["PT_IMAGE"] = "image"; + // + PrimitiveType["PT_SHAPE"] = "shape"; + // + PrimitiveType["PT_RECTANGLE"] = "rectangle"; + // + PrimitiveType["PT_BAR"] = "bar"; + // + PrimitiveType["PT_GANTT"] = "gantt"; + // + PrimitiveType["PT_SQUARE"] = "square"; + // + PrimitiveType["PT_CIRCLE"] = "circle"; + // + PrimitiveType["PT_POLYLINE"] = "polyline"; + // line chart + PrimitiveType["PT_LINE"] = "line"; + // + PrimitiveType["PT_POLYGON"] = "polygon"; + // area chart + PrimitiveType["PT_AREA"] = "area"; + // + PrimitiveType["PT_PIE"] = "pie"; + // + PrimitiveType["PT_MULTIPOLYGON"] = "multipolygon"; + // Not an actual primitive type. This is just used to flag the UI that multiple types are in play. + PrimitiveType["PT_MULTIPLE"] = "multiple"; + // used for looping over all values + PrimitiveType["NUM_PRIMITIVES"] = "count"; + // used to flag an unset or invalid state + PrimitiveType["PT_INVALID"] = "invalid"; + })(PrimitiveType = exports.PrimitiveType || (exports.PrimitiveType = {})); + // Defines the way a given primitive behaves on a viz - for instance, a PT_CIRCLE is treated as a point, while a PT_POLYGON would be treated as an area. + var MarkType; + (function (MarkType) { + // + MarkType["MT_POINT"] = "point"; + // + MarkType["MT_LINE"] = "line"; + // + MarkType["MT_AREA"] = "area"; + // + MarkType["MT_INVALID"] = "invalid"; + })(MarkType = exports.MarkType || (exports.MarkType = {})); + // PaneAxis is used to describe which axis of a pane is the independent axis. + var PaneAxis; + (function (PaneAxis) { + // The independent axis is inferred from other properties of the pane. + PaneAxis["AXIS_AUTO"] = "auto"; + // + PaneAxis["AXIS_X"] = "x"; + // + PaneAxis["AXIS_Y"] = "y"; + })(PaneAxis = exports.PaneAxis || (exports.PaneAxis = {})); + // + var Rounding; + (function (Rounding) { + // + Rounding["Rounding_None"] = "none"; + // + Rounding["Rounding_Small"] = "small"; + // + Rounding["Rounding_Medium"] = "medium"; + // + Rounding["Rounding_Large"] = "large"; + })(Rounding = exports.Rounding || (exports.Rounding = {})); + // + var LineEnd; + (function (LineEnd) { + // + LineEnd["LineEnd_None"] = "none"; + // + LineEnd["LineEnd_Arrow"] = "arrow"; + // + LineEnd["LineEnd_OpenArrow"] = "open-arrow"; + // + LineEnd["LineEnd_Dot"] = "dot"; + })(LineEnd = exports.LineEnd || (exports.LineEnd = {})); + // + var LineEndSize; + (function (LineEndSize) { + // + LineEndSize["LineEndSize_Smallest"] = "smallest"; + // + LineEndSize["LineEndSize_Smaller"] = "smaller"; + // + LineEndSize["LineEndSize_Small"] = "small"; + // + LineEndSize["LineEndSize_Medium"] = "medium"; + // + LineEndSize["LineEndSize_Large"] = "large"; + // + LineEndSize["LineEndSize_Larger"] = "larger"; + // + LineEndSize["LineEndSize_Largest"] = "largest"; + })(LineEndSize = exports.LineEndSize || (exports.LineEndSize = {})); + // + var BodyType; + (function (BodyType) { + // + BodyType["BodyType_None"] = "none"; + // + BodyType["BodyType_Box"] = "box"; + // + BodyType["BodyType_Edge"] = "edge"; + })(BodyType = exports.BodyType || (exports.BodyType = {})); + // + var StyleTheme; + (function (StyleTheme) { + // + StyleTheme["themeClassic"] = "classic"; + // + StyleTheme["themeModern"] = "modern"; + // + StyleTheme["themeClean"] = "clean"; + // + StyleTheme["themeSmooth"] = "smooth"; + // + StyleTheme["themeCustom"] = "custom"; + })(StyleTheme = exports.StyleTheme || (exports.StyleTheme = {})); + // + var AxisFoldState; + (function (AxisFoldState) { + // + AxisFoldState["afNone"] = "none"; + // + AxisFoldState["afFolded"] = "folded"; + // + AxisFoldState["afSynchronized"] = "synchronized"; + })(AxisFoldState = exports.AxisFoldState || (exports.AxisFoldState = {})); + // + var LinePattern; + (function (LinePattern) { + // + LinePattern["LinePatternNone"] = "none"; + // + LinePattern["LinePatternSolid"] = "solid"; + // + LinePattern["LinePatternDashed"] = "dashed"; + // + LinePattern["LinePatternDotted"] = "dotted"; + })(LinePattern = exports.LinePattern || (exports.LinePattern = {})); + // + var LineVisibility; + (function (LineVisibility) { + // + LineVisibility["LineVisibilityAuto"] = "automatic"; + // + LineVisibility["LineVisibilityOn"] = "on"; + // + LineVisibility["LineVisibilityOff"] = "off"; + })(LineVisibility = exports.LineVisibility || (exports.LineVisibility = {})); + // + var StylesLinePattern; + (function (StylesLinePattern) { + // + StylesLinePattern["StylesLinePatternSolid"] = "solid"; + // + StylesLinePattern["StylesLinePatternDashed"] = "dashed"; + // + StylesLinePattern["StylesLinePatternDotted"] = "dotted"; + })(StylesLinePattern = exports.StylesLinePattern || (exports.StylesLinePattern = {})); + // + var LineCap; + (function (LineCap) { + // + LineCap["LineCapFlat"] = "flat"; + // + LineCap["LineCapSquare"] = "square"; + // + LineCap["LineCapRound"] = "round"; + // + LineCap["LineCapTriangle"] = "triangle"; + })(LineCap = exports.LineCap || (exports.LineCap = {})); + // + var LineJoin; + (function (LineJoin) { + // + LineJoin["BevelJoin"] = "bevel"; + // + LineJoin["MiterJoin"] = "miter"; + // + LineJoin["RoundJoin"] = "round"; + })(LineJoin = exports.LineJoin || (exports.LineJoin = {})); + // + var LineAlignment; + (function (LineAlignment) { + // + LineAlignment["AlignmentCenter"] = "center"; + // + LineAlignment["AlignmentInset"] = "inset"; + })(LineAlignment = exports.LineAlignment || (exports.LineAlignment = {})); + // + var FillMode; + (function (FillMode) { + // + FillMode["FillEvenOdd"] = "even-odd"; + // + FillMode["FillWinding"] = "winding"; + })(FillMode = exports.FillMode || (exports.FillMode = {})); + // + var BorderStyle; + (function (BorderStyle) { + // none + BorderStyle["BorderStyleNone"] = "bs-none"; + // hidden + BorderStyle["BorderStyleHidden"] = "bs-hidden"; + // dotted + BorderStyle["BorderStyleDotted"] = "bs-dotted"; + // dashed + BorderStyle["BorderStyleDashed"] = "bs-dashed"; + // solid + BorderStyle["BorderStyleSolid"] = "bs-solid"; + // double + BorderStyle["BorderStyleDouble"] = "bs-double"; + // groove + BorderStyle["BorderStyleGroove"] = "bs-groove"; + // ridge + BorderStyle["BorderStyleRidge"] = "bs-ridge"; + // inset + BorderStyle["BorderStyleInset"] = "bs-inset"; + // outset + BorderStyle["BorderStyleOutset"] = "bs-outset"; + // invalid + BorderStyle["BorderStyleInvalid"] = "bs-invalid"; + })(BorderStyle = exports.BorderStyle || (exports.BorderStyle = {})); + // + var ColorPaletteType; + (function (ColorPaletteType) { + // + ColorPaletteType["ColorPaletteRegular"] = "color-palette-regular"; + // + ColorPaletteType["ColorPaletteOrderedDiverging"] = "palette-ordered-diverging"; + // + ColorPaletteType["ColorPaletteOrderedLinear"] = "palette-ordered-linear"; + })(ColorPaletteType = exports.ColorPaletteType || (exports.ColorPaletteType = {})); + // + var PaletteFlags; + (function (PaletteFlags) { + // + PaletteFlags["PaletteFlagNone"] = "palette-flag-none"; + // + PaletteFlags["PaletteFlagCustom"] = "palette-flag-custom"; + // + PaletteFlags["PaletteFlagNotQuantitative"] = "palette-flag-not-quantitative"; + // + PaletteFlags["PaletteFlagNotCategorical"] = "palette-flag-not-categorical"; + // + PaletteFlags["PaletteFlagNotReferenceBand"] = "palette-flag-not-reference-band"; + // + PaletteFlags["PaletteFlagNotBoxplot"] = "palette-flag-not-boxplot"; + // + PaletteFlags["PaletteFlagNotFilledMapLight"] = "palette-flag-not-filled-map-light"; + // + PaletteFlags["PaletteFlagNotFilledMapDark"] = "palette-flag-not-filled-map-dark"; + // + PaletteFlags["PaletteFlagLegacy"] = "palette-flag-legacy"; + })(PaletteFlags = exports.PaletteFlags || (exports.PaletteFlags = {})); + // + var DefaultPaletteType; + (function (DefaultPaletteType) { + // + DefaultPaletteType["SmallNominal"] = "palette-default-small-nominal"; + // + DefaultPaletteType["LargeNominal"] = "palette-default-large-nominal"; + // + DefaultPaletteType["Ordinal"] = "palette-default-ordinal"; + // + DefaultPaletteType["QuantitativePositive"] = "palette-default-quant-pos"; + // + DefaultPaletteType["QuantitativeNegative"] = "palette-default-quant-neg"; + // + DefaultPaletteType["QuantitativeDiverging"] = "palette-default-quant-div"; + // + DefaultPaletteType["QuantitativePositiveLight"] = "palette-default-quant-pos-light"; + // + DefaultPaletteType["QuantitativeNegativeLight"] = "palette-default-quant-neg-light"; + // + DefaultPaletteType["QuantitativeDivergingLight"] = "palette-default-quant-div-light"; + // + DefaultPaletteType["QuantitativePositiveArea"] = "palette-default-quant-pos-area"; + // + DefaultPaletteType["QuantitativeNegativeArea"] = "palette-default-quant-neg-area"; + // + DefaultPaletteType["QuantitativeDivergingArea"] = "palette-default-quant-div-area"; + })(DefaultPaletteType = exports.DefaultPaletteType || (exports.DefaultPaletteType = {})); + // + var ShowBounds; + (function (ShowBounds) { + // + ShowBounds["Both"] = "show-both"; + // + ShowBounds["Upper"] = "show-upper"; + // + ShowBounds["Lower"] = "show-lower"; + })(ShowBounds = exports.ShowBounds || (exports.ShowBounds = {})); + // Sample vs. population standard deviation + var StDevType; + (function (StDevType) { + // + StDevType["Sample"] = "stdev-sample"; + // + StDevType["Population"] = "stdev-population"; + })(StDevType = exports.StDevType || (exports.StDevType = {})); + // + var ReferenceLineFormulaGroup; + (function (ReferenceLineFormulaGroup) { + // + ReferenceLineFormulaGroup["None"] = "none"; + // + ReferenceLineFormulaGroup["Line"] = "line"; + // + ReferenceLineFormulaGroup["Band"] = "band"; + // + ReferenceLineFormulaGroup["Distribution"] = "distribution"; + // + ReferenceLineFormulaGroup["Boxplot"] = "boxplot"; + })(ReferenceLineFormulaGroup = exports.ReferenceLineFormulaGroup || (exports.ReferenceLineFormulaGroup = {})); + // + var ReferenceLineScopeType; + (function (ReferenceLineScopeType) { + // + ReferenceLineScopeType["PerCell"] = "per-cell"; + // + ReferenceLineScopeType["PerPane"] = "per-pane"; + // + ReferenceLineScopeType["PerTable"] = "per-table"; + })(ReferenceLineScopeType = exports.ReferenceLineScopeType || (exports.ReferenceLineScopeType = {})); + // how should the line be labeled + var ReferenceLineLabelType; + (function (ReferenceLineLabelType) { + // no label + ReferenceLineLabelType["None"] = "none"; + // an automatically generated label + ReferenceLineLabelType["Automatic"] = "automatic"; + // + ReferenceLineLabelType["Value"] = "value"; + // + ReferenceLineLabelType["Computation"] = "computation"; + // a user defined label + ReferenceLineLabelType["Custom"] = "custom"; + })(ReferenceLineLabelType = exports.ReferenceLineLabelType || (exports.ReferenceLineLabelType = {})); + // how should the line be computed + var ReferenceLineFormulaType; + (function (ReferenceLineFormulaType) { + // a user specified constant value + ReferenceLineFormulaType["Constant"] = "constant"; + // + ReferenceLineFormulaType["Total"] = "total"; + // total of all values at the given scope <- is this correct? looks like comment from FormulaTotal + ReferenceLineFormulaType["Sum"] = "sum"; + // minimum value in the scope + ReferenceLineFormulaType["Min"] = "min"; + // maximum value in the scope + ReferenceLineFormulaType["Max"] = "max"; + // average value in the scope + ReferenceLineFormulaType["Average"] = "average"; + // median value in the scope + ReferenceLineFormulaType["Median"] = "median"; + // the n quantiles values in the scope + ReferenceLineFormulaType["Quantiles"] = "quantiles"; + // a given percentile in the scope + ReferenceLineFormulaType["Percentile"] = "percentile"; + // mean +- standard deviation + ReferenceLineFormulaType["StandardDeviation"] = "standard-deviation"; + // a given confidence interval around the mean + ReferenceLineFormulaType["ConfidenceInterval"] = "confidence-interval"; + // + ReferenceLineFormulaType["MedianConfidenceInterval"] = "median-confidence-interval"; + })(ReferenceLineFormulaType = exports.ReferenceLineFormulaType || (exports.ReferenceLineFormulaType = {})); + // Line or confidence interval or both + var ReferenceLineConfidenceIntervalState; + (function (ReferenceLineConfidenceIntervalState) { + // display line only + ReferenceLineConfidenceIntervalState["LineOnly"] = "line-only"; + // display the line and a confidence interval + ReferenceLineConfidenceIntervalState["LineAndConfidenceInterval"] = "line-and-interval"; + // display confidence interval only + ReferenceLineConfidenceIntervalState["ConfidenceIntervalOnly"] = "interval-only"; + })(ReferenceLineConfidenceIntervalState = exports.ReferenceLineConfidenceIntervalState || (exports.ReferenceLineConfidenceIntervalState = {})); + // type of distribution. i.e. Percentage, Percentile, Quantile, and Standard Deviation + var ReferenceLineDistributionType; + (function (ReferenceLineDistributionType) { + // distribution type percentage + ReferenceLineDistributionType["Percentages"] = "percentages"; + // distribution type percentile + ReferenceLineDistributionType["Percentiles"] = "percentiles"; + // distribution type quantile + ReferenceLineDistributionType["Quantiles"] = "quantiles"; + // distribution type standard deviation + ReferenceLineDistributionType["StandardDeviation"] = "standard-deviation"; + })(ReferenceLineDistributionType = exports.ReferenceLineDistributionType || (exports.ReferenceLineDistributionType = {})); + // the kind of LOD calc to use for a given reference line + var ReferenceLineLODCalcType; + (function (ReferenceLineLODCalcType) { + // Create a formula using a FIXED-like level-of-detail calculation, to which sheet filters apply, that will go onto a specific sheet + ReferenceLineLODCalcType["MeasureFormula"] = "measure-formula"; + // Create a boolean formula that can be used as a filter + ReferenceLineLODCalcType["BooleanFilter"] = "boolean-filter"; + })(ReferenceLineLODCalcType = exports.ReferenceLineLODCalcType || (exports.ReferenceLineLODCalcType = {})); + // + var BoxplotWhiskerType; + (function (BoxplotWhiskerType) { + // + BoxplotWhiskerType["Standard"] = "standard"; + // + BoxplotWhiskerType["Minmax"] = "minmax"; + })(BoxplotWhiskerType = exports.BoxplotWhiskerType || (exports.BoxplotWhiskerType = {})); + // categories of connection types displayed by the connection UI + var ConnectionTypeCategory; + (function (ConnectionTypeCategory) { + // standard database + ConnectionTypeCategory["CTC_Database"] = "database"; + // 'More Items ...' meta item + ConnectionTypeCategory["CTC_More"] = "more"; + // Other file types + ConnectionTypeCategory["CTC_Other"] = "other"; + // invalid connection category + ConnectionTypeCategory["CTC_Invalid"] = "invalid"; + })(ConnectionTypeCategory = exports.ConnectionTypeCategory || (exports.ConnectionTypeCategory = {})); + // a logical grouping of connection types displayed by the connection UI + var ConnectionTypeGroup; + (function (ConnectionTypeGroup) { + // in a file + ConnectionTypeGroup["CTG_File"] = "file"; + // on a server + ConnectionTypeGroup["CTG_Server"] = "server"; + // on a recent server + ConnectionTypeGroup["CTG_MruServer"] = "mru-server"; + // invalid group + ConnectionTypeGroup["CTG_Invalid"] = "invalid"; + })(ConnectionTypeGroup = exports.ConnectionTypeGroup || (exports.ConnectionTypeGroup = {})); + // The type of metadata a column contains + var CubeMetadataCategory; + (function (CubeMetadataCategory) { + // cube's name + CubeMetadataCategory["CMC_Name"] = "name"; + // cube's description + CubeMetadataCategory["CMC_Description"] = "description"; + // cube's last updated timestamp + CubeMetadataCategory["CMC_LastUpdated"] = "last-updated"; + // invalid + CubeMetadataCategory["CMC_Invalid"] = "invalid"; + })(CubeMetadataCategory = exports.CubeMetadataCategory || (exports.CubeMetadataCategory = {})); + // The type of widget to display to the user when they are specifying connection info + var ConnectionWidgetType; + (function (ConnectionWidgetType) { + // show the join area + ConnectionWidgetType["CWT_JoinArea"] = "join-area"; + // show the cube selection ui + ConnectionWidgetType["CWT_CubeSelection"] = "cube-selection"; + // show the google analytics ui + ConnectionWidgetType["CWT_GoogleAnalytics"] = "google-analytics"; + // show the tableau server ui + ConnectionWidgetType["CWT_TableauServer"] = "tableau-server"; + // do not show any connection widget + ConnectionWidgetType["CWT_NoWidget"] = "no-widget"; + // invalid + ConnectionWidgetType["CWT_Invalid"] = "invalid"; + })(ConnectionWidgetType = exports.ConnectionWidgetType || (exports.ConnectionWidgetType = {})); + // The type of google analytics basic info + var GoogleBasicInfoType; + (function (GoogleBasicInfoType) { + // google analytics account + GoogleBasicInfoType["GA_Account"] = "ga-account"; + // google analytics property + GoogleBasicInfoType["GA_Property"] = "ga-property"; + // google analytics view + GoogleBasicInfoType["GA_View"] = "ga-view"; + // invalid + GoogleBasicInfoType["GA_Invalid"] = "invalid"; + })(GoogleBasicInfoType = exports.GoogleBasicInfoType || (exports.GoogleBasicInfoType = {})); + // The way in which a piece of connection information is specified + var ConnectionSpecificationType; + (function (ConnectionSpecificationType) { + // Uses a combo box + ConnectionSpecificationType["CST_ComboBox"] = "combo-box"; + // Uses a line edit + ConnectionSpecificationType["CST_LineEdit"] = "line-edit"; + // Uses a line edit with a browse button next to it + ConnectionSpecificationType["CST_LineEditBrowse"] = "line-edit-browse"; + // invalid + ConnectionSpecificationType["CST_Invalid"] = "invalid"; + })(ConnectionSpecificationType = exports.ConnectionSpecificationType || (exports.ConnectionSpecificationType = {})); + // GA Date Range + var DateRange; + (function (DateRange) { + // + DateRange["DateRangeFirst"] = "date-range-first"; + // + DateRange["DateRangeLast30Days"] = "date-range-last30"; + // + DateRange["DateRangeToday"] = "date-range-today"; + // + DateRange["DateRangeYesterday"] = "date-range-yesterday"; + // + DateRange["DateRangeLastWeek"] = "date-range-last-week"; + // + DateRange["DateRangeLastMonth"] = "date-range-last-month"; + // + DateRange["DateRangeLastYear"] = "date-range-last-year"; + // + DateRange["DateRangeThisWeekToYesterday"] = "date-range-this-week-to-yesterday"; + // + DateRange["DateRangeThisMonthToYesterday"] = "date-range-this-month-to-yesterday"; + // + DateRange["DateRangeThisYearToYesterday"] = "date-range-this-year-to-yesterday"; + // + DateRange["DateRangeLastWeekToYesterday"] = "date-range-last-week-to-yesterday"; + // + DateRange["DateRangeLastMonthToYesterday"] = "date-range-last-month-to-yesterday"; + // + DateRange["DateRangeLastYearToYesterday"] = "date-range-last-year-to-yesterday"; + // + DateRange["DateRangeFixedRange"] = "date-range-fixed-range"; + // + DateRange["DateRangeFixedStart"] = "date-range-fixed-start"; + // + DateRange["DateRangeCount"] = "date-range-count"; + })(DateRange = exports.DateRange || (exports.DateRange = {})); + // Specifies the type of widget to show in ConnectServerWidget + var ConnectServerWidgetType; + (function (ConnectServerWidgetType) { + // invalid + ConnectServerWidgetType["CSWT_Invalid"] = "invalid"; + // microsoft access + ConnectServerWidgetType["CSWT_Access"] = "access"; + // generic odbc + ConnectServerWidgetType["CSWT_ODBC"] = "odbc"; + // cubes + ConnectServerWidgetType["CSWT_Cube"] = "cube"; + // relational data sources + ConnectServerWidgetType["CSWT_Relational"] = "relational"; + })(ConnectServerWidgetType = exports.ConnectServerWidgetType || (exports.ConnectServerWidgetType = {})); + // + var AuthenticationEnumsMode; + (function (AuthenticationEnumsMode) { + // no authentication widget + AuthenticationEnumsMode["AuthModeNone"] = "auth-mode-none"; + // username and password + AuthenticationEnumsMode["AuthModeBasic"] = "auth-mode-basic"; + // username and password can be blank + AuthenticationEnumsMode["AuthModeBasicNoValidateFields"] = "auth-mode-basic-no-validate-fields"; + // only username + AuthenticationEnumsMode["AuthModeBasicUserNameOnly"] = "auth-mode-basic-username-only"; + // aws access key and secret ID + AuthenticationEnumsMode["AuthModeBasicAWS"] = "auth-mode-basic-aws"; + // username, password, and a list of AuthOptions with radio buttons + AuthenticationEnumsMode["AuthModeRadio"] = "auth-mode-radio"; + // Like AuthModeRadio, but enable username/password even for integrated auth + AuthenticationEnumsMode["AuthModeRadioUnindented"] = "auth-mode-radio-unindented"; + // username, password, and a list of AuthOptions with a combobox + AuthenticationEnumsMode["AuthModeComboBox"] = "auth-mode-combobox"; + // Like AuthModeCombobox, but with option not requiring username/password + AuthenticationEnumsMode["AuthModeComboBoxIntegrated"] = "auth-mode-combobox-integrated"; + // driver, authentication, username, realm, etc + AuthenticationEnumsMode["AuthModeHive"] = "auth-mode-hive"; + // none, azure marketplace account, explicit + AuthenticationEnumsMode["AuthModeOData"] = "auth-mode-odata"; + // edition, authentication, sso domain, etc + AuthenticationEnumsMode["AuthModeSharePoint"] = "auth-mode-sharepoint"; + // username, password, client, & language + AuthenticationEnumsMode["AuthModeSAPBW"] = "auth-mode-sapbw"; + // Ability to switch between two different auth modes each in their own modal dialogs (basic and oauth) + AuthenticationEnumsMode["AuthModeSwitchModal"] = "auth-mode-switch-modal"; + })(AuthenticationEnumsMode = exports.AuthenticationEnumsMode || (exports.AuthenticationEnumsMode = {})); + // + var AuthenticationEnumsReconnectMode; + (function (AuthenticationEnumsReconnectMode) { + // Auth not needed for reconnect + AuthenticationEnumsReconnectMode["ReconnectModeNone"] = "reconnect-mode-none"; + // Username and password + AuthenticationEnumsReconnectMode["ReconnectModeBasic"] = "reconnect-mode-basic"; + // Access file + AuthenticationEnumsReconnectMode["ReconnectModeAccess"] = "reconnect-mode-access"; + // Microsoft Azure Data Market (OData) + AuthenticationEnumsReconnectMode["ReconnectModeDataMarket"] = "reconnect-mode-data-market"; + // Google OAuth + AuthenticationEnumsReconnectMode["ReconnectModeGoogleOAuth"] = "reconnect-mode-google-oauth"; + // SalesforceOAuth, with the option of username/password auth + AuthenticationEnumsReconnectMode["ReconnectModeSalesforceOAuth"] = "reconnect-mode-salesforce-oauth"; + // Web data connector + AuthenticationEnumsReconnectMode["ReconnectModeWebData"] = "reconnect-mode-web-data"; + })(AuthenticationEnumsReconnectMode = exports.AuthenticationEnumsReconnectMode || (exports.AuthenticationEnumsReconnectMode = {})); + // + var AuthenticationEnumsAuthOption; + (function (AuthenticationEnumsAuthOption) { + // FIRST + AuthenticationEnumsAuthOption["AuthExplicit"] = "auth-option-explicit"; + // + AuthenticationEnumsAuthOption["AuthExplicitUnindented"] = "auth-option-explicit-unindented"; + // + AuthenticationEnumsAuthOption["AuthUseWindows"] = "auth-option-use-windows"; + // + AuthenticationEnumsAuthOption["AuthUseWindowsPreferred"] = "auth-option-windows-preferred"; + // + AuthenticationEnumsAuthOption["AuthTeradata"] = "auth-option-teradata"; + // + AuthenticationEnumsAuthOption["AuthLDAP"] = "auth-option-ldap"; + // + AuthenticationEnumsAuthOption["AuthVirtualNode"] = "auth-option-virtual-node"; + // + AuthenticationEnumsAuthOption["AuthODataAccount"] = "auth-option-odata"; + // + AuthenticationEnumsAuthOption["AuthNone"] = "auth-option-none"; + // + AuthenticationEnumsAuthOption["AuthKerberos"] = "auth-option-kerberos"; + // Introduced for Kerberos with fallback, recognizing that the db may or may not be on Windows + AuthenticationEnumsAuthOption["AuthIntegrated"] = "auth-option-integrated"; + // + AuthenticationEnumsAuthOption["AuthUsername"] = "auth-option-username"; + // + AuthenticationEnumsAuthOption["AuthUsernameAndPassword"] = "auth-option-username-and-password"; + // + AuthenticationEnumsAuthOption["AuthSSL"] = "auth-option-ssl"; + // + AuthenticationEnumsAuthOption["AuthHDIEmulator"] = "auth-hdi-emulator"; + // + AuthenticationEnumsAuthOption["AuthHDIService"] = "auth-hdi-service"; + // + AuthenticationEnumsAuthOption["AuthHTTP"] = "auth-http"; + // + AuthenticationEnumsAuthOption["AuthHTTPS"] = "auth-https"; + // + AuthenticationEnumsAuthOption["AuthAccessNoSecurity"] = "auth-option-access-no"; + // + AuthenticationEnumsAuthOption["AuthAccessYesSecurity"] = "auth-option-access-yes"; + // + AuthenticationEnumsAuthOption["AuthOAuth"] = "auth-oauth"; + // + AuthenticationEnumsAuthOption["AuthForms"] = "auth-forms"; + // + AuthenticationEnumsAuthOption["AuthThirdPartySSO"] = "auth-third-party-SSO"; + // LAST + AuthenticationEnumsAuthOption["AuthInvalid"] = "auth-option-invalid"; + // + AuthenticationEnumsAuthOption["AuthSAMLIdP"] = "auth-option-saml-idp"; + })(AuthenticationEnumsAuthOption = exports.AuthenticationEnumsAuthOption || (exports.AuthenticationEnumsAuthOption = {})); + // data source validation modes + var DataSourceParserValidationMode; + (function (DataSourceParserValidationMode) { + // + DataSourceParserValidationMode["WorkbookLoadValidation"] = "workbook-load-validation"; + // + DataSourceParserValidationMode["AutoValidation"] = "auto-validation"; + // + DataSourceParserValidationMode["ForceValidation"] = "force-validation"; + // + DataSourceParserValidationMode["PreventValidation"] = "prevent-validation"; + // + DataSourceParserValidationMode["PreventValidationAndThrow"] = "prevent-validation-and-throw"; + })(DataSourceParserValidationMode = exports.DataSourceParserValidationMode || (exports.DataSourceParserValidationMode = {})); + // Enum for DataGrid/MetadataGrid fields reordering + var FieldOrderType; + (function (FieldOrderType) { + // + FieldOrderType["DATASOURCE_ORDER"] = "datasource-order"; + // + FieldOrderType["ALPHA_PER_TABLE"] = "alpha-per-table"; + // + FieldOrderType["ALPHABETICAL_ORDER"] = "alphabetical-order"; + // + FieldOrderType["CUSTOM_ORDER"] = "custom-order"; + })(FieldOrderType = exports.FieldOrderType || (exports.FieldOrderType = {})); + // + var LineInterpolationMode; + (function (LineInterpolationMode) { + // + LineInterpolationMode["LIM_Linear"] = "lim-linear"; + // + LineInterpolationMode["LIM_Step"] = "lim-step"; + // + LineInterpolationMode["LIM_Jump"] = "lim-jump"; + })(LineInterpolationMode = exports.LineInterpolationMode || (exports.LineInterpolationMode = {})); + // + var LineMarkerPosition; + (function (LineMarkerPosition) { + // + LineMarkerPosition["LMP_Left"] = "lmp-left"; + // + LineMarkerPosition["LMP_Center"] = "lmp-center"; + // + LineMarkerPosition["LMP_Right"] = "lmp-right"; + })(LineMarkerPosition = exports.LineMarkerPosition || (exports.LineMarkerPosition = {})); + // + var FolderRole; + (function (FolderRole) { + // + FolderRole["FOLDER_DIMENSIONS"] = "dimensions"; + // + FolderRole["FOLDER_MEASURES"] = "measure"; + // + FolderRole["FOLDER_GROUPS"] = "groups"; + // + FolderRole["FOLDER_PARAMETERS"] = "parameters"; + })(FolderRole = exports.FolderRole || (exports.FolderRole = {})); + // + var FieldTypeIconSet; + (function (FieldTypeIconSet) { + // + FieldTypeIconSet["FT_SET_ALL"] = "all"; + // + FieldTypeIconSet["FT_SET_CUBE_MEASURES"] = "cube-measures"; + // + FieldTypeIconSet["FT_SET_CUBE_DIMENSIONS"] = "cube-dimensions"; + })(FieldTypeIconSet = exports.FieldTypeIconSet || (exports.FieldTypeIconSet = {})); + // + var FieldPivotStrategy; + (function (FieldPivotStrategy) { + // + FieldPivotStrategy["PIVOT_ON_KEY"] = "pivot-on-key"; + // + FieldPivotStrategy["PIVOT_ON_ALIAS"] = "pivot-on-alias"; + })(FieldPivotStrategy = exports.FieldPivotStrategy || (exports.FieldPivotStrategy = {})); + // + var AliasType; + (function (AliasType) { + // + AliasType["ALIAS_NOTSET"] = "alias-not-set"; + // + AliasType["ALIAS_BEGIN"] = "alias-begin"; + // + AliasType["ALIAS_KEY"] = "alias-key"; + // + AliasType["ALIAS_KEY_NAME"] = "alias-key-name"; + // + AliasType["ALIAS_KEY_MEDNAME"] = "alias-key-medname"; + // + AliasType["ALIAS_KEY_LONGNAME"] = "alias-key-longname"; + // + AliasType["ALIAS_NAME"] = "alias-name"; + // + AliasType["ALIAS_NAME_KEY"] = "alias-name-key"; + // + AliasType["ALIAS_MEDNAME"] = "alias-medname"; + // + AliasType["ALIAS_MEDNAME_KEY"] = "alias-medname-key"; + // + AliasType["ALIAS_LONGNAME"] = "alias-longname"; + // + AliasType["ALIAS_LONGNAME_KEY"] = "alias-longname-key"; + // + AliasType["ALIAS_END"] = "alias-end"; + })(AliasType = exports.AliasType || (exports.AliasType = {})); + // + var AliasTypes; + (function (AliasTypes) { + // + AliasTypes["MASK_ALIAS_KEY"] = "mask-alias-key"; + // + AliasTypes["MASK_ALIAS_NAME"] = "mask-alias-name"; + // + AliasTypes["MASK_ALIAS_MEDNAME"] = "mask-alias-medname"; + // + AliasTypes["MASK_ALIAS_LONGNAME"] = "mask-alias-longname"; + })(AliasTypes = exports.AliasTypes || (exports.AliasTypes = {})); + // + var FieldRole; + (function (FieldRole) { + // + FieldRole["ROLE_DIMENSION"] = "dimension"; + // + FieldRole["ROLE_MEASURE"] = "measure"; + // + FieldRole["ROLE_UNKNOWN"] = "unknown"; + })(FieldRole = exports.FieldRole || (exports.FieldRole = {})); + // + var FieldType; + (function (FieldType) { + // + FieldType["TYPE_QUANTITATIVE"] = "quantitative"; + // + FieldType["TYPE_ORDINAL"] = "ordinal"; + // + FieldType["TYPE_NOMINAL"] = "nominal"; + // + FieldType["TYPE_UNKNOWN"] = "unknown"; + })(FieldType = exports.FieldType || (exports.FieldType = {})); + // + var DataSourceOrder; + (function (DataSourceOrder) { + // + DataSourceOrder["DSO_ALPHABETIC"] = "dso-alphabetic"; + // + DataSourceOrder["DSO_ORDINAL"] = "dso-ordinal"; + })(DataSourceOrder = exports.DataSourceOrder || (exports.DataSourceOrder = {})); + // Where the column comes from + var ColumnClass; + (function (ColumnClass) { + // A metadata column (O or Q Measures) + ColumnClass["COL_METADATA"] = "col-metadata"; + // A physical column on the database + ColumnClass["COL_DATABASE"] = "col-database"; + // A numberic bin (a special kind of calculated column) + ColumnClass["COL_NUMERICBIN"] = "col-numericbin"; + // A Categorical bin (group) + ColumnClass["COL_CATEGORICALBIN"] = "col-categoricalbin"; + // A column instance + ColumnClass["COL_INSTANCE"] = "col-instance"; + // A (raw) mdx calculated column + ColumnClass["COL_MDXCALC"] = "col-mdxcalc"; + // A user-defined calculated column, Tableau expression syntax + ColumnClass["COL_USERCALC"] = "col-usercalc"; + // A column that would have been COL_DATABASE, but the underlying database column does not exist + ColumnClass["COL_DANGLING"] = "col-dangling"; + // A column that contains local supplied data (e.g. Latitude) + ColumnClass["COL_LOCALDATA"] = "col-localdata"; + // A column that contains a visual model attribute (e.g. PaneIndex, Color, ...) + ColumnClass["COL_VISUALDATA"] = "col-visualdata"; + // A column that's a Group (a " Set " in UI terminology) + ColumnClass["COL_GROUP"] = "col-group"; + })(ColumnClass = exports.ColumnClass || (exports.ColumnClass = {})); + // + var VTAggType; + (function (VTAggType) { + // + VTAggType["VTAGG_SUM"] = "sum"; + // + VTAggType["VTAGG_AVG"] = "avg"; + // + VTAggType["VTAGG_MIN"] = "min"; + // + VTAggType["VTAGG_MAX"] = "max"; + // + VTAggType["VTAGG_SERVER"] = "server"; + // + VTAggType["VTAGG_NONE"] = "none"; + // + VTAggType["VTAGG_DEFAULT"] = "default"; + })(VTAggType = exports.VTAggType || (exports.VTAggType = {})); + // + var EntityType; + (function (EntityType) { + // + EntityType["NoEnumerationEntity"] = "no-enumeration-entity"; + // + EntityType["DatabaseEntity"] = "database-entity"; + // + EntityType["SchemaEntity"] = "schema-entity"; + // + EntityType["TableEntity"] = "table-entity"; + })(EntityType = exports.EntityType || (exports.EntityType = {})); + // + var PickEntitySearchType; + (function (PickEntitySearchType) { + // + PickEntitySearchType["PickEntitySearchType_StartsWith"] = "starts-with"; + // + PickEntitySearchType["PickEntitySearchType_Contains"] = "contains"; + // + PickEntitySearchType["PickEntitySearchType_ExactMatch"] = "exact-match"; + // + PickEntitySearchType["PickEntitySearchType_DEFAULT"] = "default"; + })(PickEntitySearchType = exports.PickEntitySearchType || (exports.PickEntitySearchType = {})); + // Parsing methods and structures. + var ExpressionOp; + (function (ExpressionOp) { + // + ExpressionOp["LogicalOr"] = "op-logical-or"; + // + ExpressionOp["LogicalAnd"] = "op-logical-and"; + // + ExpressionOp["LogicalNot"] = "op-logical-not"; + // + ExpressionOp["BitwiseXOr"] = "op-bitwise-xor"; + // + ExpressionOp["BitwiseOr"] = "op-bitwise-or"; + // + ExpressionOp["Equals"] = "op-equals"; + // + ExpressionOp["Greater"] = "op-greater"; + // + ExpressionOp["Less"] = "op-less"; + // + ExpressionOp["GEqual"] = "op-gequal"; + // + ExpressionOp["LEqual"] = "op-lequal"; + // + ExpressionOp["NEqual"] = "op-nequal"; + // + ExpressionOp["Plus"] = "op-plus"; + // + ExpressionOp["Minus"] = "op-minus"; + // + ExpressionOp["BitwiseAnd"] = "op-bitwise-and"; + // + ExpressionOp["Multiply"] = "op-multiply"; + // + ExpressionOp["Divide"] = "op-divide"; + // + ExpressionOp["Modulo"] = "op-modulo"; + // + ExpressionOp["Power"] = "op-power"; + // + ExpressionOp["Positive"] = "op-positive"; + // + ExpressionOp["Negative"] = "op-negative"; + // + ExpressionOp["BitwiseNot"] = "op-bitwise-not"; + // + ExpressionOp["Column"] = "op-column"; + // + ExpressionOp["String"] = "op-string"; + // + ExpressionOp["Number"] = "op-number"; + // + ExpressionOp["Date"] = "op-date"; + // + ExpressionOp["Boolean"] = "op-boolean"; + // + ExpressionOp["Funcall"] = "op-funcall"; + // + ExpressionOp["LParen"] = "op-lparen"; + // + ExpressionOp["RParen"] = "op-rparen"; + // + ExpressionOp["Comma"] = "op-comma"; + // + ExpressionOp["Ident"] = "op-ident"; + // + ExpressionOp["Null"] = "op-null"; + // + ExpressionOp["If"] = "op-if"; + // + ExpressionOp["Elseif"] = "op-elseif"; + // + ExpressionOp["Case"] = "op-case"; + // + ExpressionOp["When"] = "op-when"; + // + ExpressionOp["Then"] = "op-then"; + // + ExpressionOp["Else"] = "op-else"; + // + ExpressionOp["EndExpr"] = "op-endexpr"; + // + ExpressionOp["Whitespace"] = "op-whitespace"; + // + ExpressionOp["Comment"] = "op-comment"; + // + ExpressionOp["LBrace"] = "op-lbrace"; + // + ExpressionOp["RBrace"] = "op-rbrace"; + // + ExpressionOp["Colon"] = "op-colon"; + // + ExpressionOp["Bar"] = "op-bar"; + // + ExpressionOp["Txtype"] = "op-txtype"; + // + ExpressionOp["End"] = "op-end"; + // + ExpressionOp["RBrackets"] = "op-rbrackets"; + // used to represent invalid tokens + ExpressionOp["Invalid"] = "op-invalid"; + })(ExpressionOp = exports.ExpressionOp || (exports.ExpressionOp = {})); + // tri-state bool + var TriBool; + (function (TriBool) { + // + TriBool["TB_Invalid"] = "tribool-invalid"; + // + TriBool["TB_False"] = "tribool-false"; + // + TriBool["TB_True"] = "tribool-true"; + })(TriBool = exports.TriBool || (exports.TriBool = {})); + // table calc reference options set + var ReferenceOptionsSet; + (function (ReferenceOptionsSet) { + // + ReferenceOptionsSet["ROS_Relative"] = "reference-options-set-relative"; + // + ReferenceOptionsSet["ROS_Fixed"] = "reference-options-set-fixed"; + // + ReferenceOptionsSet["ROS_Parameter"] = "reference-options-set-parameter"; + // + ReferenceOptionsSet["ROS_None"] = "reference-options-set-none"; + })(ReferenceOptionsSet = exports.ReferenceOptionsSet || (exports.ReferenceOptionsSet = {})); + // widget state + var WidgetState; + (function (WidgetState) { + // + WidgetState["Hidden"] = "widget-state-hidden"; + // + WidgetState["Disabled"] = "widget-state-disabled"; + // + WidgetState["Enabled"] = "widget-state-enabled"; + })(WidgetState = exports.WidgetState || (exports.WidgetState = {})); + // rank type + var RankType; + (function (RankType) { + // + RankType["Competition"] = "rank-type-competition"; + // + RankType["ModifiedCompetition"] = "rank-type-modified-competition"; + // + RankType["Dense"] = "rank-type-dense"; + // + RankType["Unique"] = "rank-type-unique"; + })(RankType = exports.RankType || (exports.RankType = {})); + // + var TableCalcCommandType; + (function (TableCalcCommandType) { + // + TableCalcCommandType["TableCalcCommandClear"] = "clear"; + })(TableCalcCommandType = exports.TableCalcCommandType || (exports.TableCalcCommandType = {})); + // + var CalcNestingLevel; + (function (CalcNestingLevel) { + // + CalcNestingLevel["Primary"] = "primary"; + // used only for type != TC_CUSTOM + CalcNestingLevel["Secondary"] = "secondary"; + // used only for type == TC_CUSTOM + CalcNestingLevel["Nested"] = "nested"; + })(CalcNestingLevel = exports.CalcNestingLevel || (exports.CalcNestingLevel = {})); + // + var DecimalMode; + (function (DecimalMode) { + // + DecimalMode["DecimalModeAutomatic"] = "automatic"; + // + DecimalMode["DecimalModeManual"] = "manual"; + })(DecimalMode = exports.DecimalMode || (exports.DecimalMode = {})); + // + var TableCalcOrderingType; + (function (TableCalcOrderingType) { + // Advanced... + TableCalcOrderingType["OTField"] = "field"; + // Table (Across) + TableCalcOrderingType["OTRows"] = "rows"; + // Table (Down) + TableCalcOrderingType["OTColumns"] = "columns"; + // Table (Across then Down) + TableCalcOrderingType["OTTable"] = "table"; + // Table (Down then Across) + TableCalcOrderingType["OTTableColumnPrecedence"] = "table-column-precedence"; + // Pane Across + TableCalcOrderingType["OTRowInPane"] = "row-in-pane"; + // Pane (Down) + TableCalcOrderingType["OTColumnInPane"] = "column-in-pane"; + // Pane (Across then Down) + TableCalcOrderingType["OTPane"] = "pane"; + // Pane (Down then Across) + TableCalcOrderingType["OTPaneColumnPrecedence"] = "pane-column-precedence"; + // Cell + TableCalcOrderingType["OTCellInPane"] = "cell-in-pane"; + })(TableCalcOrderingType = exports.TableCalcOrderingType || (exports.TableCalcOrderingType = {})); + // + var TableCalcSortMode; + (function (TableCalcSortMode) { + // + TableCalcSortMode["SM_Automatic"] = "sort-mode-automatic"; + // + TableCalcSortMode["SM_Custom"] = "sort-mode-custom"; + })(TableCalcSortMode = exports.TableCalcSortMode || (exports.TableCalcSortMode = {})); + // + var TableCalcTableCalcType; + (function (TableCalcTableCalcType) { + // none (used to initialize variables) + TableCalcTableCalcType["TC_NONE"] = "none"; + // Running Total + TableCalcTableCalcType["TC_CUMULATIVE"] = "cumulative"; + // Moving Calculation + TableCalcTableCalcType["TC_WINDOW"] = "window"; + // Difference From + TableCalcTableCalcType["TC_DIFF"] = "diff"; + // Percent Difference From + TableCalcTableCalcType["TC_PCTDIFF"] = "pct-diff"; + // Percent From + TableCalcTableCalcType["TC_PCTVALUE"] = "pct-value"; + // Percent Of Total + TableCalcTableCalcType["TC_PCTTOTAL"] = "pct-total"; + // Rank + TableCalcTableCalcType["TC_RANK"] = "rank"; + // Percentile + TableCalcTableCalcType["TC_PCTRANK"] = "pct-rank"; + // Custom + TableCalcTableCalcType["TC_CUSTOM"] = "custom"; + })(TableCalcTableCalcType = exports.TableCalcTableCalcType || (exports.TableCalcTableCalcType = {})); + // + var QuickTableCalcCommandType; + (function (QuickTableCalcCommandType) { + // + QuickTableCalcCommandType["QuickTableCalcCommandRunTotal"] = "run-total"; + // + QuickTableCalcCommandType["QuickTableCalcCommandDifference"] = "difference"; + // + QuickTableCalcCommandType["QuickTableCalcCommandPctDiff"] = "pct-diff"; + // + QuickTableCalcCommandType["QuickTableCalcCommandPctTotal"] = "pct-total"; + // + QuickTableCalcCommandType["QuickTableCalcCommandRank"] = "rank"; + // + QuickTableCalcCommandType["QuickTableCalcCommandPctRank"] = "pct-rank"; + // + QuickTableCalcCommandType["QuickTableCalcCommandMovingAvg"] = "moving-avg"; + // + QuickTableCalcCommandType["QuickTableCalcCommandYtd"] = "ytd"; + // + QuickTableCalcCommandType["QuickTableCalcCommandCgr"] = "cgr"; + // + QuickTableCalcCommandType["QuickTableCalcCommandYOverY"] = "y-over-y"; + // + QuickTableCalcCommandType["QuickTableCalcCommandYtdGrowth"] = "ytd-growth"; + // + QuickTableCalcCommandType["QuickTableCalcCommandCustom"] = "custom"; + })(QuickTableCalcCommandType = exports.QuickTableCalcCommandType || (exports.QuickTableCalcCommandType = {})); + // + var TableCalcAddressCommandType; + (function (TableCalcAddressCommandType) { + // + TableCalcAddressCommandType["TableCalcAddressCommandRel"] = "rel"; + // + TableCalcAddressCommandType["TableCalcAddressCommandAbs"] = "abs"; + // + TableCalcAddressCommandType["TableCalcAddressCommandParam"] = "param"; + // + TableCalcAddressCommandType["TableCalcAddressCommandMore"] = "more"; + })(TableCalcAddressCommandType = exports.TableCalcAddressCommandType || (exports.TableCalcAddressCommandType = {})); + // relative addressing + var TableCalcRelativeAddress; + (function (TableCalcRelativeAddress) { + // + TableCalcRelativeAddress["RelAddrFirst"] = "relative-address-first"; + // + TableCalcRelativeAddress["RelAddrPrevious"] = "relative-address-previous"; + // + TableCalcRelativeAddress["RelAddrNext"] = "relative-address-next"; + // + TableCalcRelativeAddress["RelAddrLast"] = "relative-address-last"; + })(TableCalcRelativeAddress = exports.TableCalcRelativeAddress || (exports.TableCalcRelativeAddress = {})); + // + var CategoricalBinItemType; + (function (CategoricalBinItemType) { + // + CategoricalBinItemType["Unbinned"] = "unbinned"; + // + CategoricalBinItemType["BinMember"] = "categorical-bin-member"; + // + CategoricalBinItemType["Bin"] = "categorical-bin"; + })(CategoricalBinItemType = exports.CategoricalBinItemType || (exports.CategoricalBinItemType = {})); + // The class properties + var CredentialTypePropertiesFlag; + (function (CredentialTypePropertiesFlag) { + // + CredentialTypePropertiesFlag["None"] = "none"; + // + CredentialTypePropertiesFlag["GenericAuthClass"] = "generic-auth-class"; + // + CredentialTypePropertiesFlag["ProviderClass"] = "provider-class"; + // + CredentialTypePropertiesFlag["DataConnectionClass"] = "data-connection-class"; + })(CredentialTypePropertiesFlag = exports.CredentialTypePropertiesFlag || (exports.CredentialTypePropertiesFlag = {})); + // The connector type + var ConnectorType; + (function (ConnectorType) { + // + ConnectorType["Invalid"] = "invalid"; + // + ConnectorType["WebDataConnector"] = "web-data-connector"; + // + ConnectorType["CloudFileConnector"] = "cloud-file-connector"; + // + ConnectorType["LegacyConnector"] = "legacy-connector"; + })(ConnectorType = exports.ConnectorType || (exports.ConnectorType = {})); + // + var TablePillIcon; + (function (TablePillIcon) { + // + TablePillIcon["ListItem"] = "list-item"; + // + TablePillIcon["Sheet"] = "sheet"; + // + TablePillIcon["FoundTable"] = "found-table"; + // + TablePillIcon["NamedRange"] = "named-range"; + // + TablePillIcon["StoredProcedure"] = "stored-procedure"; + })(TablePillIcon = exports.TablePillIcon || (exports.TablePillIcon = {})); + // + var JoinValidationError; + (function (JoinValidationError) { + // + JoinValidationError["JVE_NoError"] = "no-error"; + // + JoinValidationError["JVE_EmptyClause"] = "empty-clause"; + // + JoinValidationError["JVE_TypeMismatch"] = "type-mismatch"; + // + JoinValidationError["JVE_InvalidField"] = "invalid-field"; + // + JoinValidationError["JVE_BadClause"] = "bad-clause"; + // + JoinValidationError["JVE_BadInputRelation"] = "bad-input-relation"; + // + JoinValidationError["JVE_RepeatedFieldReferences"] = "repeated-field-references"; + // + JoinValidationError["JVE_UnsupportedJoinType"] = "unsupported-join-type"; + // + JoinValidationError["JVE_InvalidCalculation"] = "invalid-calculation"; + // + JoinValidationError["JVE_NonSpatialType"] = "non-spatial-type"; + // + JoinValidationError["JVE_NonSpatialComparison"] = "non-spatial-comp"; + // + JoinValidationError["JVE_Unknown"] = "unknown"; + })(JoinValidationError = exports.JoinValidationError || (exports.JoinValidationError = {})); + // + var ConnectionTypeEnum; + (function (ConnectionTypeEnum) { + // -d-s is used to force the enum generator to generate DS with capital letters in .cs just like the .cpp + ConnectionTypeEnum["InvalidDS"] = "invalid-d-s"; + // + ConnectionTypeEnum["FileDS"] = "file-d-s"; + // + ConnectionTypeEnum["ServerDS"] = "server-d-s"; + // + ConnectionTypeEnum["InternetDS"] = "internet-d-s"; + // + ConnectionTypeEnum["TableauServerDS"] = "tableau-server-d-s"; + })(ConnectionTypeEnum = exports.ConnectionTypeEnum || (exports.ConnectionTypeEnum = {})); + // + var ConnectionErrorStage; + (function (ConnectionErrorStage) { + // + ConnectionErrorStage["Unknown"] = "unknown"; + // + ConnectionErrorStage["CreateProtocolFailed"] = "create-protocol-failed"; + // + ConnectionErrorStage["LoadMetadataFailed"] = "load-metadata-failed"; + })(ConnectionErrorStage = exports.ConnectionErrorStage || (exports.ConnectionErrorStage = {})); + // + var SortDirection; + (function (SortDirection) { + // ascending + SortDirection["ST_ASC"] = "asc"; + // descending + SortDirection["ST_DESC"] = "desc"; + })(SortDirection = exports.SortDirection || (exports.SortDirection = {})); + // + var SortType; + (function (SortType) { + // Use the defined ordering + SortType["ST_NATURAL"] = "data-source-order"; + // Alphabetic/numeric ordering of data + SortType["ST_ALPHABETIC"] = "alpha"; + // Specify a secondary field + SortType["ST_COMPUTED"] = "field"; + // Manually defined ordering + SortType["ST_MANUAL"] = "manual"; + })(SortType = exports.SortType || (exports.SortType = {})); + // + var SortEnd; + (function (SortEnd) { + // + SortEnd["ST_TOP"] = "top"; + // + SortEnd["ST_BOTTOM"] = "bottom"; + })(SortEnd = exports.SortEnd || (exports.SortEnd = {})); + // Enumeration for the type of join connecting two tables + var SQLJoinType; + (function (SQLJoinType) { + // + SQLJoinType["SQL_InnerJoin"] = "sql-inner-join"; + // + SQLJoinType["SQL_LeftJoin"] = "sql-left-join"; + // + SQLJoinType["SQL_RightJoin"] = "sql-right-join"; + // + SQLJoinType["SQL_FullJoin"] = "sql-full-join"; + // + SQLJoinType["SQL_CrossJoin"] = "sql-cross-join"; + })(SQLJoinType = exports.SQLJoinType || (exports.SQLJoinType = {})); + // The result of parsing and setting a data value for a property of a quantitative axis. + var SetAxisDataValueResult; + (function (SetAxisDataValueResult) { + // + SetAxisDataValueResult["Success"] = "set-axis-data-value-result-success"; + // + SetAxisDataValueResult["ParseFailure"] = "set-axis-data-value-result-parse-failure"; + // + SetAxisDataValueResult["ValueFailure"] = "set-axis-data-value-result-value-failure"; + })(SetAxisDataValueResult = exports.SetAxisDataValueResult || (exports.SetAxisDataValueResult = {})); + // The type of an axis' extent + var AxisExtentType; + (function (AxisExtentType) { + // + AxisExtentType["Automatic"] = "axis-extent-automatic"; + // + AxisExtentType["Uniform"] = "axis-extent-uniform"; + // + AxisExtentType["Independent"] = "axis-extent-independent"; + // + AxisExtentType["Fixed"] = "axis-extent-fixed"; + })(AxisExtentType = exports.AxisExtentType || (exports.AxisExtentType = {})); + // Enumeration of units tick spacing can take + var TickSpacingUnits; + (function (TickSpacingUnits) { + // + TickSpacingUnits["NoUnits"] = "no-units"; + // + TickSpacingUnits["Years"] = "years"; + // + TickSpacingUnits["Quarters"] = "quarters"; + // + TickSpacingUnits["Months"] = "months"; + // + TickSpacingUnits["Weeks"] = "weeks"; + // + TickSpacingUnits["Days"] = "days"; + // + TickSpacingUnits["Hours"] = "hours"; + // + TickSpacingUnits["Minutes"] = "minutes"; + // + TickSpacingUnits["Seconds"] = "seconds"; + })(TickSpacingUnits = exports.TickSpacingUnits || (exports.TickSpacingUnits = {})); + // Enumeration of whether totals are included in or excluded from the color encoding + var TotalsInclusion; + (function (TotalsInclusion) { + // Totals included in color encoding + TotalsInclusion["IncludeTotals"] = "include-totals"; + // Totals excluded from color encoding + TotalsInclusion["ExcludeTotals"] = "exclude-totals"; + })(TotalsInclusion = exports.TotalsInclusion || (exports.TotalsInclusion = {})); + // How tick marks are being calculated + var TickMarkState; + (function (TickMarkState) { + // + TickMarkState["TicksAutomatic"] = "ticks-automatic"; + // + TickMarkState["TicksManual"] = "ticks-manual"; + // + TickMarkState["TicksNone"] = "ticks-None"; + })(TickMarkState = exports.TickMarkState || (exports.TickMarkState = {})); + // Setting for type of axis range + var AxisRangeType; + (function (AxisRangeType) { + // + AxisRangeType["AutomaticRange"] = "automatic-range"; + // + AxisRangeType["UniformRange"] = "uniform-range"; + // + AxisRangeType["IndependentRange"] = "independent-range"; + // + AxisRangeType["FixedRange"] = "fixed-range"; + // + AxisRangeType["FixedMin"] = "fixed-min"; + // + AxisRangeType["FixedMax"] = "fixed-max"; + // + AxisRangeType["FixedMinUniformMax"] = "fixed-min-uniform-max"; + // + AxisRangeType["FixedMinIndependentMax"] = "fixed-min-independent-max"; + // + AxisRangeType["FixedMaxUniformMin"] = "fixed-max-uniform-min"; + // + AxisRangeType["FixedMaxIndependentMin"] = "fixed-max-independent-min"; + // + AxisRangeType["FixedRangeOrdinal"] = "fixed-range-ordinal"; + })(AxisRangeType = exports.AxisRangeType || (exports.AxisRangeType = {})); + // represents type of widget on the toolbar of rich text editor + var RichTextEditorWidgetKey; + (function (RichTextEditorWidgetKey) { + // + RichTextEditorWidgetKey["None"] = "none"; + // + RichTextEditorWidgetKey["FontSize"] = "fontsize"; + // + RichTextEditorWidgetKey["FontName"] = "fontname"; + // + RichTextEditorWidgetKey["FontColor"] = "color"; + // + RichTextEditorWidgetKey["Bold"] = "bold"; + // + RichTextEditorWidgetKey["Italic"] = "italic"; + // + RichTextEditorWidgetKey["Underline"] = "underline"; + // + RichTextEditorWidgetKey["AlignLeft"] = "justifyleft"; + // + RichTextEditorWidgetKey["AlignCenter"] = "justifycenter"; + // + RichTextEditorWidgetKey["AlignRight"] = "justifyright"; + // + RichTextEditorWidgetKey["ClearFormatting"] = "clearformatting"; + // + RichTextEditorWidgetKey["TableauKeywords"] = "tableaukeywords"; + })(RichTextEditorWidgetKey = exports.RichTextEditorWidgetKey || (exports.RichTextEditorWidgetKey = {})); + // + var CellSizeChange; + (function (CellSizeChange) { + // + CellSizeChange["CSC_Taller"] = "taller"; + // + CellSizeChange["CSC_Shorter"] = "shorter"; + // + CellSizeChange["CSC_Wider"] = "wider"; + // + CellSizeChange["CSC_Narrower"] = "narrower"; + // + CellSizeChange["CSC_Bigger"] = "bigger"; + // + CellSizeChange["CSC_Smaller"] = "smaller"; + })(CellSizeChange = exports.CellSizeChange || (exports.CellSizeChange = {})); + // + var CellTypeEnum; + (function (CellTypeEnum) { + // + CellTypeEnum["CLT_Square"] = "square"; + // + CellTypeEnum["CLT_Text"] = "text"; + })(CellTypeEnum = exports.CellTypeEnum || (exports.CellTypeEnum = {})); + // represents type of formatting pres model + var TypeOfFormatItem; + (function (TypeOfFormatItem) { + // + TypeOfFormatItem["FT_FormatItem"] = "formatItem"; + // + TypeOfFormatItem["FT_FormatContainer"] = "formatContainer"; + // + TypeOfFormatItem["FT_FormatControl"] = "formatControl"; + })(TypeOfFormatItem = exports.TypeOfFormatItem || (exports.TypeOfFormatItem = {})); + // represents type of formatting container + var TypeOfFormatContainer; + (function (TypeOfFormatContainer) { + // + TypeOfFormatContainer["FT_FormatPane"] = "formatPane"; + // + TypeOfFormatContainer["FT_FormatSection"] = "formatSection"; + // + TypeOfFormatContainer["FT_CollapsibleSection"] = "collapsibleSection"; + // + TypeOfFormatContainer["FT_CompositeContainer"] = "compositeContainer"; + // + TypeOfFormatContainer["FT_UnitContainer"] = "unitContainer"; + // + TypeOfFormatContainer["FT_Tab"] = "tab"; + // + TypeOfFormatContainer["FT_TabGroup"] = "tabGroup"; + })(TypeOfFormatContainer = exports.TypeOfFormatContainer || (exports.TypeOfFormatContainer = {})); + // represents type of formatting control + var TypeOfFormatControl; + (function (TypeOfFormatControl) { + // + TypeOfFormatControl["FT_None"] = "none"; + // + TypeOfFormatControl["FT_NumericControl"] = "numeric-control"; + // + TypeOfFormatControl["FT_TextControl"] = "text-control"; + // + TypeOfFormatControl["FT_ColorControl"] = "color-control"; + // + TypeOfFormatControl["FT_SelectorControl"] = "selector-control"; + // + TypeOfFormatControl["FT_ToggleControl"] = "toggle-control"; + })(TypeOfFormatControl = exports.TypeOfFormatControl || (exports.TypeOfFormatControl = {})); + // represents type of formatting widget + var FormatWidgetKey; + (function (FormatWidgetKey) { + // + FormatWidgetKey["FWK_None"] = "none"; + // + FormatWidgetKey["FWK_FontFamily"] = "fontFamily"; + // + FormatWidgetKey["FWK_FontSize"] = "fontSize"; + // + FormatWidgetKey["FWK_ColorSwatch"] = "colorSwatch"; + // + FormatWidgetKey["FWK_Bold"] = "bold"; + // + FormatWidgetKey["FWK_Italics"] = "italics"; + // + FormatWidgetKey["FWK_Underline"] = "underline"; + // + FormatWidgetKey["FWK_LineVisibility"] = "lineVisibility"; + // + FormatWidgetKey["FWK_LinePattern"] = "linePattern"; + // + FormatWidgetKey["FWK_LineSize"] = "lineSize"; + // + FormatWidgetKey["FWK_NumberType"] = "numericType"; + // + FormatWidgetKey["FWK_DecimalPlaces"] = "decimalPlaces"; + // + FormatWidgetKey["FWK_ThousandsSeparator"] = "thousandsSeparator"; + // + FormatWidgetKey["FWK_NumericUnits"] = "numericUnits"; + })(FormatWidgetKey = exports.FormatWidgetKey || (exports.FormatWidgetKey = {})); + // represents identifier for each node in format pane + var FormatNodeIdentifier; + (function (FormatNodeIdentifier) { + // + FormatNodeIdentifier["Format_None_Key"] = "none"; + // + FormatNodeIdentifier["Format_Workbook_Key"] = "workbook"; + // + FormatNodeIdentifier["Format_Font_Key"] = "font"; + // + FormatNodeIdentifier["Format_Color_Key"] = "color"; + // + FormatNodeIdentifier["Format_Lines_Key"] = "lines"; + // + FormatNodeIdentifier["Format_FontAll_Key"] = "font-all"; + // + FormatNodeIdentifier["Format_FontAllControls_Key"] = "font-all-controls"; + // + FormatNodeIdentifier["Format_FontMore_Key"] = "font-more"; + // + FormatNodeIdentifier["Format_FontWorksheetTitles_Key"] = "worksheet-titles"; + // + FormatNodeIdentifier["Format_FontToolTip_Key"] = "font-tooltip"; + // + FormatNodeIdentifier["Format_FontWorksheet_Key"] = "font-worksheet"; + // + FormatNodeIdentifier["Format_FontDashTitles_Key"] = "dash-titles"; + // + FormatNodeIdentifier["Format_FontStoryTitles_Key"] = "story-titles"; + // + FormatNodeIdentifier["Format_FontTitlesControls_Key"] = "titles-controls"; + // + FormatNodeIdentifier["Format_FontTooltipControls_Key"] = "tooltip-controls"; + // + FormatNodeIdentifier["Format_FontWorksheetControls_Key"] = "worksheet-controls"; + // + FormatNodeIdentifier["Format_LineMore_Key"] = "line-more"; + // + FormatNodeIdentifier["Format_LineGrid_Key"] = "line-grid"; + // + FormatNodeIdentifier["Format_LineGridTabs_Key"] = "line-grid-tabs"; + // + FormatNodeIdentifier["Format_LineZero_Key"] = "line-zero"; + // + FormatNodeIdentifier["Format_LineZeroTabs_Key"] = "line-zero-tabs"; + // + FormatNodeIdentifier["Format_LineAxisTick_Key"] = "line-axis-tick"; + // + FormatNodeIdentifier["Format_LineAxisTickTabs_Key"] = "line-axis-tick-tabs"; + // + FormatNodeIdentifier["Format_LineAxisRuler_Key"] = "line-axis-ruler"; + // + FormatNodeIdentifier["Format_LineAxisRulerTabs_Key"] = "line-axis-ruler-tabs"; + // + FormatNodeIdentifier["Format_LineHeaderDivider_Key"] = "line-header-divider"; + // + FormatNodeIdentifier["Format_LineHeaderDividerTabs_Key"] = "line-header-divider-tabs"; + // + FormatNodeIdentifier["Format_LinePaneDivider_Key"] = "line-paneDivider"; + // + FormatNodeIdentifier["Format_LinePaneDividerTabs_Key"] = "line-paneDivider-tabs"; + // + FormatNodeIdentifier["Format_LineGridAll_Key"] = "line-grid-all"; + // + FormatNodeIdentifier["Format_LineGridRow_Key"] = "line-grid-row"; + // + FormatNodeIdentifier["Format_LineGridColumn_Key"] = "line-grid-column"; + // + FormatNodeIdentifier["Format_LineZeroAll_Key"] = "line-zero-all"; + // + FormatNodeIdentifier["Format_LineZeroRow_Key"] = "line-zero-row"; + // + FormatNodeIdentifier["Format_LineZeroColumn_Key"] = "line-zero-column"; + // + FormatNodeIdentifier["Format_LineAxisTickAll_Key"] = "line-axis-tick-all"; + // + FormatNodeIdentifier["Format_LineAxisTickRow_Key"] = "line-axis-tick-row"; + // + FormatNodeIdentifier["Format_LineAxisTickColumn_Key"] = "line-axis-tick-column"; + // + FormatNodeIdentifier["Format_LineAxisRulerAll_Key"] = "line-axis-ruler-all"; + // + FormatNodeIdentifier["Format_LineAxisRulerRow_Key"] = "line-axis-ruler-row"; + // + FormatNodeIdentifier["Format_LineAxisRulerColumn_Key"] = "line-axis-ruler-column"; + // + FormatNodeIdentifier["Format_LineReference_Key"] = "line-reference"; + // + FormatNodeIdentifier["Format_LineDrop_Key"] = "line-drop"; + // + FormatNodeIdentifier["Format_LineTrend_Key"] = "line-trend"; + // + FormatNodeIdentifier["Format_LineVisibility_Key"] = "line-visibility"; + // + FormatNodeIdentifier["Format_LinePattern_Key"] = "line-pattern"; + // + FormatNodeIdentifier["Format_LineWidth_Key"] = "line-width"; + // + FormatNodeIdentifier["Format_LineColor_Key"] = "line-color"; + // + FormatNodeIdentifier["Format_TickColor_Key"] = "tick-color"; + // + FormatNodeIdentifier["Format_BorderPattern_Key"] = "border-pattern"; + // + FormatNodeIdentifier["Format_BorderColor_Key"] = "border-color"; + // + FormatNodeIdentifier["Format_DividerColor_Key"] = "divider-color"; + // + FormatNodeIdentifier["Format_FontFamily_Key"] = "font-family-key"; + // + FormatNodeIdentifier["Format_FontSize_Key"] = "font-size-key"; + // + FormatNodeIdentifier["Format_Bold_Key"] = "bold-key"; + // + FormatNodeIdentifier["Format_Italics_Key"] = "italics-key"; + // + FormatNodeIdentifier["Format_Underline_Key"] = "underline-key"; + // + FormatNodeIdentifier["Format_FontColor_Key"] = "font-color-key"; + // + FormatNodeIdentifier["Format_Number_Container_Key"] = "number-container"; + // + FormatNodeIdentifier["Format_Number_Type_Key"] = "number-container-type"; + // + FormatNodeIdentifier["Format_Number_Units_Key"] = "number-container-units"; + // + FormatNodeIdentifier["Format_Number_Decimal_Key"] = "number-container-decimal"; + // + FormatNodeIdentifier["Format_Number_Thousands_Separator_Key"] = "number-container-thousands-separator"; + // + FormatNodeIdentifier["Format_FontPickerMinimal_Key"] = "font-picker-minimal"; + // + FormatNodeIdentifier["Format_FontPickerDefault_Key"] = "font-picker-default"; + // + FormatNodeIdentifier["Format_LinePickerDefault_Key"] = "line-picker-default"; + // + FormatNodeIdentifier["Format_LinePickerNoVis_Key"] = "line-picker-no-visibility"; + // + FormatNodeIdentifier["Format_LineAxisTickPicker_Key"] = "line-axis-tick-picker"; + })(FormatNodeIdentifier = exports.FormatNodeIdentifier || (exports.FormatNodeIdentifier = {})); + // represents the color swatch that will be used in the ColorControlPresModel + var ColorSwatchType; + (function (ColorSwatchType) { + // + ColorSwatchType["CST_Dark"] = "dark-swatch"; + // + ColorSwatchType["CST_Light"] = "light-swatch"; + })(ColorSwatchType = exports.ColorSwatchType || (exports.ColorSwatchType = {})); + // represents the type of a style picker, affecting the preview rendering and, possibly, the layout + var PickerType; + (function (PickerType) { + // + PickerType["PT_None"] = "none"; + // + PickerType["PT_Font"] = "font"; + // + PickerType["PT_Line"] = "line"; + // + PickerType["PT_Number"] = "number"; + })(PickerType = exports.PickerType || (exports.PickerType = {})); + // + var UpdateScope; + (function (UpdateScope) { + // + UpdateScope["US_Worksheet"] = "worksheet"; + // + UpdateScope["US_Dashboard"] = "dashboard"; + // + UpdateScope["US_QuickFilters"] = "quick-filters"; + // + UpdateScope["US_Story"] = "story"; + })(UpdateScope = exports.UpdateScope || (exports.UpdateScope = {})); + // + var ParameterCtrlTypesDisplayMode; + (function (ParameterCtrlTypesDisplayMode) { + // + ParameterCtrlTypesDisplayMode["MODE_TYPE_IN"] = "type_in"; + // + ParameterCtrlTypesDisplayMode["MODE_COMPACT_LIST"] = "compact"; + // + ParameterCtrlTypesDisplayMode["MODE_LIST"] = "list"; + // + ParameterCtrlTypesDisplayMode["MODE_SLIDER"] = "slider"; + // + ParameterCtrlTypesDisplayMode["MODE_DATETIME"] = "datetime"; + })(ParameterCtrlTypesDisplayMode = exports.ParameterCtrlTypesDisplayMode || (exports.ParameterCtrlTypesDisplayMode = {})); + // flags for display options + var ParameterCtrlTypesDisplayFlag; + (function (ParameterCtrlTypesDisplayFlag) { + // + ParameterCtrlTypesDisplayFlag["DISPLAY_CUSTOM_TITLE"] = "custom_title"; + // + ParameterCtrlTypesDisplayFlag["DISPLAY_HIDE_SLIDER_SLIDER"] = "hide_slider_slider"; + // + ParameterCtrlTypesDisplayFlag["DISPLAY_HIDE_SLIDER_READOUT"] = "hide_slider_readout"; + // + ParameterCtrlTypesDisplayFlag["DISPLAY_HIDE_SLIDER_BUTTONS"] = "hide_slider_buttons"; + })(ParameterCtrlTypesDisplayFlag = exports.ParameterCtrlTypesDisplayFlag || (exports.ParameterCtrlTypesDisplayFlag = {})); + // The follow supports 1024 custom palettes, each with 4m shapes. Encoding is palette << PaletteShift | shape. + var ShapeEncodeConstants; + (function (ShapeEncodeConstants) { + // Shift value for palette + ShapeEncodeConstants["EncodePaletteShift"] = "paletteShift"; + // Mask for getting palette from encoded value. (Then shift down) + ShapeEncodeConstants["EncodePaletteMask"] = "paletteMask"; + // Mask for getting shape from encoded value + ShapeEncodeConstants["EncodeShapeMask"] = "shapeMask"; + })(ShapeEncodeConstants = exports.ShapeEncodeConstants || (exports.ShapeEncodeConstants = {})); + // + var ShapeType; + (function (ShapeType) { + // + ShapeType["ShapeCircle"] = "circle"; + // + ShapeType["ShapeSquare"] = "square"; + // + ShapeType["ShapePlus"] = "plus"; + // + ShapeType["ShapeTimes"] = "times"; + // + ShapeType["ShapeAsterisk"] = "asterisk"; + // + ShapeType["ShapeDiamond"] = "diamond"; + // + ShapeType["ShapeTriangle"] = "triangle"; + // + ShapeType["ShapeDownTriangle"] = "down-triangle"; + // + ShapeType["ShapeLeftTriangle"] = "left-triangle"; + // + ShapeType["ShapeRightTriangle"] = "right-triangle"; + // + ShapeType["MaxAllShapes"] = "invalid"; + })(ShapeType = exports.ShapeType || (exports.ShapeType = {})); + // + var ShapePalette; + (function (ShapePalette) { + // built-in palette + ShapePalette["ShapePaletteFilled"] = "filled"; + // custom palettes + ShapePalette["ShapePaletteCustom1"] = "custom1"; + // + ShapePalette["ShapePaletteCustom2"] = "custom2"; + // + ShapePalette["ShapePaletteCustom3"] = "custom3"; + // + ShapePalette["ShapePaletteCustom4"] = "custom4"; + // + ShapePalette["ShapePaletteCustom5"] = "custom5"; + // + ShapePalette["ShapePaletteCustom6"] = "custom6"; + // + ShapePalette["ShapePaletteCustom7"] = "custom7"; + // + ShapePalette["ShapePaletteCustom8"] = "custom8"; + // + ShapePalette["ShapePaletteCustom9"] = "custom9"; + // + ShapePalette["ShapePaletteCustom10"] = "custom10"; + // + ShapePalette["ShapePaletteCustom11"] = "custom11"; + // and so on... + ShapePalette["ShapePaletteCustom12"] = "custom12"; + // + ShapePalette["ShapePaletteHidden"] = "hidden"; + })(ShapePalette = exports.ShapePalette || (exports.ShapePalette = {})); + // ShapeType and palette mapped into a single value. This enum depends on ShapeType and the implementation of ShapeManager::IntEncode. + var ShapeID; + (function (ShapeID) { + // + ShapeID["ShapeIDCircle"] = "shapeIDCircle"; + // + ShapeID["ShapeIDSquare"] = "shapeIDSquare"; + // + ShapeID["ShapeIDPlus"] = "shapeIDPlus"; + // + ShapeID["ShapeIDTimes"] = "shapeIDTimes"; + // + ShapeID["ShapeIDAsterisk"] = "shapeIDAsterisk"; + // + ShapeID["ShapeIDDiamond"] = "shapeIDDiamond"; + // + ShapeID["ShapeIDTriangle"] = "shapeIDTriangle"; + // + ShapeID["ShapeIDDownTriangle"] = "shapeIDDownTriangle"; + // + ShapeID["ShapeIDLeftTriangle"] = "shapeIDLeftTriangle"; + // + ShapeID["ShapeIDRightTriangle"] = "shapeIDRightTriangle"; + // + ShapeID["ShapeIDFilledCircle"] = "shapeIDFilledCircle"; + // + ShapeID["ShapeIDFilledSquare"] = "shapeIDFilledSquare"; + // + ShapeID["ShapeIDFilledPlus"] = "shapeIDFilledPlus"; + // + ShapeID["ShapeIDFilledTimes"] = "shapeIDFilledTimes"; + // + ShapeID["ShapeIDFilledStar"] = "shapeIDFilledStar"; + // + ShapeID["ShapeIDFilledDiamond"] = "shapeIDFilledDiamond"; + // + ShapeID["ShapeIDFilledTriangle"] = "shapeIDFilledTriangle"; + // + ShapeID["ShapeIDFilledDownTriangle"] = "shapeIDFilledDownTriangle"; + // + ShapeID["ShapeIDFilledLeftTriangle"] = "shapeIDFilledLeftTriangle"; + // + ShapeID["ShapeIDFilledRightTriangle"] = "shapeIDFilledRightTriangle"; + // 0+(ShapePaletteHidden< -1; + }); + // Create a mapping of which index in the data dictionary our columns are in + var columnIndices = columns.map(function (vizDataColumn) { + // The columnIndex is in the same position as the paneIndex + var paneIndex = vizDataColumn.paneIndices.indexOf(i); + var columnIndex = vizDataColumn.columnIndices[paneIndex]; + return columnIndex; + }); + // Get the data for the pane we are processing + var vizPane = vizData.paneColumnsData.paneColumnsList[i]; + if (vizPane.vizPaneColumns.length !== columns.length) { + throw api_utils_1.TableauException.error(ActiveMarksDataConverter.MALFORMED_DATA); + } + var headers = new Array(); + var rows = new Array(); + // Column 0 will be the tuple id column. We can use this as a counter for how many rows we have + var tupleIds = vizPane.vizPaneColumns[0].tupleIds; + var marks = new Array(); + for (var tupleIndex = 0; tupleIndex < tupleIds.length; tupleIndex++) { + // TODO Need to revaluate the place of this logic. If it turns out that we need a separate command + // call to get the marks info, then this logic should not be here but instead in a layer above somewhere + var mark = { + type: api_internal_contract_1.MarkType.Bar, + color: 'red', + tupleId: tupleIds[tupleIndex], + }; + marks.push(mark); + // We will have 1 less value in this row since there's the tupleId column + var cells = new Array(vizPane.vizPaneColumns.length - 1); + for (var j = 1 /* skip the first which is tuple ids */; j < vizPane.vizPaneColumns.length; j++) { + // Next, we need to figure out which column we are reading data for + var column = columns[columnIndices[j]]; + var vizPaneColumnData = vizPane.vizPaneColumns[j]; + // Define the header when we are processing the first row + if (tupleIndex === 0) { + var header = { + dataType: EnumMappings_1.PresLayerToApiEnumMappings.dataType.convert(column.dataType), + fieldName: column.fn, + isReferenced: true, + index: j - 1, + fieldCaption: column.fieldCaption + }; + headers.push(header); + } + var value = UnderlyingDataConverter_1.UnderlyingDataConverter.lookupValueFromDictionary(dataDictionary, column.dataType, vizPaneColumnData.valueIndices[tupleIndex]); + var aliasValue = UnderlyingDataConverter_1.UnderlyingDataConverter.lookupValueFromDictionary(dataDictionary, column.dataType, vizPaneColumnData.aliasIndices[tupleIndex]) || ''; + var formattedValue = aliasValue; // TODO - Figure out how to use the formatStrings + var dataCell = { + value: value, + formattedValue: formattedValue, + aliasedValue: aliasValue + }; + // Add our cell to this row + cells[j - 1] = dataCell; + } + rows.push(cells); + } + var dataTable = { + dataTable: rows, + headers: headers, + marks: marks + }; + result.push(dataTable); + }; + // The data model for the VizDataPresModel is a little strange, so this parsing takes some time to figure out. + // There can be multiple panes of data, so we must go through them one at a time to create data tables + for (var i = 0; i < vizData.paneColumnsData.paneColumnsList.length; i++) { + _loop_1(i); + } + return result; + }; + ActiveMarksDataConverter.MALFORMED_DATA = 'Malformed data table'; + return ActiveMarksDataConverter; + }()); + exports.ActiveMarksDataConverter = ActiveMarksDataConverter; + + +/***/ }, +/* 93 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var Enums = __webpack_require__(90); + var EnumMappings_1 = __webpack_require__(89); + var api_utils_1 = __webpack_require__(80); + /** + * Contains static helper methods for converting from an underlying data pres model into the api representation. + * Most of the code is a direct port from ApiUnderlyingDataHandler.cs + * https://opengrok/source/xref/teams_near/workgroup/vqlweb/scriptsharp/src/UI/Api/ApiUnderlyingDataHandler.cs + */ + var UnderlyingDataConverter = (function () { + function UnderlyingDataConverter() { + } + UnderlyingDataConverter.lookupValueFromDictionary = function (dataDictionary, dt, index) { + if (index < 0) { + // per cl 280396 / bugzid 81197 negative data value index means that it is special + dt = Enums.DataType.DT_STRING; + index = -index - 1; + } + var result = null; + var rawValue = UnderlyingDataConverter.getRawValue(dataDictionary, dt, index); + if (rawValue !== null) { + result = rawValue.toString(); + } + return result; + }; + /* tslint:disable-next-line:no-any */ + UnderlyingDataConverter.getRawValue = function (dataDictionary, dt, index) { + if (!dataDictionary.dataSegments) { + return null; + } + for (var _i = 0, _a = Object.keys(dataDictionary.dataSegments); _i < _a.length; _i++) { + var key = _a[_i]; + var dataSegment = dataDictionary.dataSegments[key]; + for (var _b = 0, _c = dataSegment.dataColumns; _b < _c.length; _b++) { + var dataColumn = _c[_b]; + if (!dataColumn || dataColumn.dataType !== dt) { + continue; + } + if (index < dataColumn.dataValues.length) { + return dataColumn.dataValues[index]; + } + index -= dataColumn.dataValues.length; + break; + } + } + return null; + }; + UnderlyingDataConverter.buildDataTable = function (dataDictionary, columns) { + var result = { + dataTable: UnderlyingDataConverter.buildTable(dataDictionary, columns), + headers: columns.map(function (c, i) { return UnderlyingDataConverter.buildColumnModel(c, i); }) + }; + return result; + }; + UnderlyingDataConverter.buildUnderlyingDataTable = function (isSummary, underlyingDataTable) { + var result = { + data: UnderlyingDataConverter.buildDataTable(underlyingDataTable.dataDictionary, underlyingDataTable.underlyingDataTableColumns), + isSummary: isSummary + }; + return result; + }; + UnderlyingDataConverter.buildActiveMarksTable = function (dataDictionary, vizData) { + throw api_utils_1.TableauException.apiNotImplemented(['buildActiveMarksTable']); + }; + UnderlyingDataConverter.buildColumnModel = function (column, index) { + return { + dataType: EnumMappings_1.PresLayerToApiEnumMappings.dataType.convert(column.dataType), + fieldName: column.fn, + fieldCaption: column.fieldCaption, + isReferenced: !!column.isReferenced, + index: index + }; + }; + UnderlyingDataConverter.buildTable = function (dataDictionary, columns) { + if (columns.length === 0) { + return new Array(); + } + var rowCount = columns[0].formatValIdxs.length; + var columnCount = columns.length; + var result = new Array(rowCount); + // Initialize all of our rows + for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) { + result[rowIndex] = new Array(columnCount); + } + // Go through column-by-column and convert the values + for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) { + var column = columns[columnIndex]; + for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) { + var formattedValue = UnderlyingDataConverter.lookupValueFromDictionary(dataDictionary, Enums.DataType.DT_STRING, column.formatValIdxs[rowIndex]); + if (formattedValue === null) { + throw api_utils_1.TableauException.isNull(['formattedValue']); + } + var value = { + value: UnderlyingDataConverter.lookupValueFromDictionary(dataDictionary, column.dataType, column.valueIndices[rowIndex]), + formattedValue: formattedValue, + aliasedValue: formattedValue + }; + result[rowIndex][columnIndex] = value; + } + } + return result; + }; + return UnderlyingDataConverter; + }()); + exports.UnderlyingDataConverter = UnderlyingDataConverter; + + +/***/ }, +/* 94 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(80); + var EnumMappings_1 = __webpack_require__(89); + /** + * Class containing helper methods for converting from ApiPresModels to their PresLayer equivalents + * + * @export + * @class ApiToPresLayerConverter + */ + var ApiToPresLayerConverter = (function () { + function ApiToPresLayerConverter() { + } + ApiToPresLayerConverter.convertSheetPath = function (apiSheetPath) { + if (!apiSheetPath) { + throw api_utils_1.TableauException.isUndefined(['sheetPath']); + } + var result = { + sheetName: apiSheetPath.sheetName, + isDashboard: apiSheetPath.isDashboard, + storyboard: apiSheetPath.storyboard || '', + flipboardZoneId: apiSheetPath.flipboardZoneID || 0, + storyPointId: apiSheetPath.storyPointID || 0, + }; + return result; + }; + ApiToPresLayerConverter.convertExtensionLocator = function (apiExtensionLocator) { + var result = { + addInInstanceId: apiExtensionLocator.instanceId, + sheetPath: ApiToPresLayerConverter.convertSheetPath(apiExtensionLocator.dashboardPath) + }; + return result; + }; + ApiToPresLayerConverter.convertVisualId = function (apiVisualid) { + var result = { + worksheet: apiVisualid.worksheet, + dashboard: apiVisualid.dashboard, + storyboard: apiVisualid.storyboard, + storyPointId: apiVisualid.storyPointID, + flipboardZoneId: apiVisualid.flipboardZoneID + }; + return result; + }; + ApiToPresLayerConverter.convertVisualIdToWorksheet = function (apiVisualId) { + return apiVisualId.worksheet; + }; + ApiToPresLayerConverter.convertVisualIdToDashboard = function (apiVisualId) { + return apiVisualId.dashboard || ''; + }; + ApiToPresLayerConverter.convertFilterValues = function (filterValues) { + if (filterValues.length === 0) { + // platform code expects an empty string for clearing filter values + return ['']; + } + return filterValues; + }; + ApiToPresLayerConverter.convertFilterType = function (filterUpdateType) { + return EnumMappings_1.ApiToPresLayerEnumMappings.filterUpdateType.convert(filterUpdateType); + }; + ApiToPresLayerConverter.ConvertNullOption = function (nullOption) { + return EnumMappings_1.ApiToPresLayerEnumMappings.nullOption.convert(nullOption); + }; + ApiToPresLayerConverter.ConvertFilterDomainType = function (filterDomainType) { + return EnumMappings_1.ApiToPresLayerEnumMappings.filterDomainType.convert(filterDomainType); + }; + return ApiToPresLayerConverter; + }()); + exports.ApiToPresLayerConverter = ApiToPresLayerConverter; + + +/***/ }, +/* 95 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var Enums_1 = __webpack_require__(90); + var EnumMappings_1 = __webpack_require__(89); + var PresLayerToApiConverter_1 = __webpack_require__(88); + var FiltersConverter = (function () { + function FiltersConverter() { + } + FiltersConverter.convertFiltersPresModel = function (filterPms) { + var filters = []; + filterPms.forEach(function (filterPm) { + switch (filterPm.filterType) { + case Enums_1.FilterType.FLTR_Categorical: { + filters.push(FiltersConverter.convertCategoricalFilterPresModel(filterPm)); + break; + } + case Enums_1.FilterType.FLTR_Quantitative: { + filters.push(FiltersConverter.convertQuantitativeFilterPresModel(filterPm)); + break; + } + case Enums_1.FilterType.FLTR_RelativeDate: { + filters.push(FiltersConverter.convertRelativeDateFilterPresModel(filterPm)); + break; + } + default: + return; + } + }); + return filters; + }; + FiltersConverter.convertCategoricalFilterPresModel = function (filterPm) { + var selectedValues = filterPm.categoricalFilterInfo.captionedFilterValueList.map(function (filterValue) { + return FiltersConverter.convertFilterValuePresModel(filterValue); + }); + var filter = { + values: selectedValues, + isExclude: filterPm.categoricalFilterInfo.exclude, + filterType: api_internal_contract_1.FilterType.Categorical, + fieldCaption: filterPm.fieldCaption, + fieldName: filterPm.fn, + visualId: PresLayerToApiConverter_1.PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel) + }; + return filter; + }; + FiltersConverter.convertQuantitativeFilterPresModel = function (filterPm) { + var minValue = FiltersConverter.convertFilterValuePresModel(filterPm.quantitativeFilterInfo.captionedRangeMin); + var maxValue = FiltersConverter.convertFilterValuePresModel(filterPm.quantitativeFilterInfo.captionedRangeMax); + var filter = { + filterType: api_internal_contract_1.FilterType.Range, + fieldCaption: filterPm.fieldCaption, + fieldName: filterPm.fn, + visualId: PresLayerToApiConverter_1.PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel), + min: minValue, + max: maxValue, + includeNullValues: FiltersConverter.convertIncludedNullValues(filterPm.quantitativeFilterInfo.included) + }; + return filter; + }; + FiltersConverter.convertRelativeDateFilterPresModel = function (filterPm) { + var anchorDateValue = FiltersConverter.convertFilterValuePresModel(filterPm.relativeDateFilterInfo.captionedAnchorDate); + var filter = { + filterType: api_internal_contract_1.FilterType.RelativeDate, + fieldCaption: filterPm.fieldCaption, + fieldName: filterPm.fn, + visualId: PresLayerToApiConverter_1.PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel), + anchorDate: anchorDateValue, + periodType: EnumMappings_1.PresLayerToApiEnumMappings.dateStepPeriod.convert(filterPm.relativeDateFilterInfo.datePeriodType), + rangeType: EnumMappings_1.PresLayerToApiEnumMappings.dateRangeType.convert(filterPm.relativeDateFilterInfo.dateRangeType), + rangeN: filterPm.relativeDateFilterInfo.rangeN + }; + return filter; + }; + FiltersConverter.convertCategoricalDomain = function (domainPm) { + var domainValues = domainPm.captionedFilterValueList.map(function (filterValue) { + return FiltersConverter.convertFilterValuePresModel(filterValue); + }); + return { values: domainValues }; + }; + FiltersConverter.convertQuantitativeDomain = function (domainPm) { + var minValue = FiltersConverter.convertFilterValuePresModel(domainPm.captionedRangeMin); + var maxValue = FiltersConverter.convertFilterValuePresModel(domainPm.captionedRangeMax); + return { + max: maxValue, + min: minValue + }; + }; + FiltersConverter.convertFilterValuePresModel = function (dvPM) { + /*tslint:disable-next-line:no-any */ + var value; + switch (dvPM.dataType) { + case Enums_1.DataType.DT_BOOLEAN: { + value = Boolean(dvPM.dataValueStr); + break; + } + case Enums_1.DataType.DT_DATE: { + value = new Date(dvPM.dataValueStr); + break; + } + case Enums_1.DataType.DT_DATETIME: { + value = new Date(dvPM.dataValueStr); + break; + } + case Enums_1.DataType.DT_INTEGER: { + value = Number.parseInt(dvPM.dataValueStr); + break; + } + case Enums_1.DataType.DT_REAL: { + value = Number.parseFloat(dvPM.dataValueStr); + break; + } + // default to string + default: { + value = dvPM.dataValueStr; + break; + } + } + return { + value: value, + // TODO: no easy way of getting back aliased value from platform, will need to investigate further + aliasedValue: '', + formattedValue: dvPM.dataValueDisplayString + }; + }; + FiltersConverter.convertIncludedNullValues = function (includeNull) { + return (includeNull === Enums_1.FiltersQuantitativeIncludedValues.InRangeOrNull || + includeNull === Enums_1.FiltersQuantitativeIncludedValues.All || + includeNull === Enums_1.FiltersQuantitativeIncludedValues.Null); + }; + return FiltersConverter; + }()); + exports.FiltersConverter = FiltersConverter; + + +/***/ }, +/* 96 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_utils_1 = __webpack_require__(80); + /** + * Simple registry class which creates a mapping based on two keys. + * + * @export + * @class MappingRegistry + * @template TInputEnumType + * @template TOutputEnumType + * @template TMappingStorageType + */ + var MappingRegistry = (function () { + function MappingRegistry() { + this._registry = {}; + } + MappingRegistry.prototype.has = function (inputType, outputType) { + var key = this.makeKey(inputType, outputType); + if (!this._registry.hasOwnProperty(key)) { + return false; + } + if (!this._registry[key]) { + return false; + } + return true; + }; + MappingRegistry.prototype.get = function (inputType, outputType) { + if (!this.has(inputType, outputType)) { + throw api_utils_1.TableauException.error(MappingRegistry.MISSING_REQUESTED_MAPPING, [inputType, outputType]); + } + var key = this.makeKey(inputType, outputType); + return this._registry[key]; + }; + MappingRegistry.prototype.addRegistration = function (inputType, outputType, storageItem) { + var key = this.makeKey(inputType, outputType); + // Add this item + this._registry[key] = storageItem; + }; + /** + * Combines the two keys into a unique string + * + * @private + * @param {TInputEnumType} inputType + * @param {TOutputEnumType} outputType + * @returns {string} + * @memberof MappingRegistry + */ + MappingRegistry.prototype.makeKey = function (inputType, outputType) { + var keyObj = { input: inputType, output: outputType }; + return JSON.stringify(keyObj); + }; + MappingRegistry.MISSING_REQUESTED_MAPPING = 'Missing requested mapping: %1 to %2'; + return MappingRegistry; + }()); + exports.MappingRegistry = MappingRegistry; + + +/***/ }, +/* 97 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var api_internal_contract_1 = __webpack_require__(79); + var api_utils_1 = __webpack_require__(80); + var EnumMappings_1 = __webpack_require__(89); + /** + * Contains logic for converting Parameter models into their equivalent Api versions + */ + var ParametersDataConverter = (function () { + function ParametersDataConverter() { + } + ParametersDataConverter.convertParameterList = function (parameters) { + return parameters.map(ParametersDataConverter.convertParameter); + }; + // Converts a single parameter. + // Rough port of https://opengrok/source/xref/dev_nessie/workgroup/vqlweb/scriptsharp/src/UI/Api/ApiParameterHandler.cs#95 + ParametersDataConverter.convertParameter = function (param) { + var currentValue = ParametersDataConverter.convertAliasedDataValue(param.valueAlias, param.formattedValue); + var allowableValuesType = EnumMappings_1.PresLayerToApiEnumMappings.parameterTypesDomainType.convert(param.parameterDomainType); + var result = { + name: param.fieldCaption, + fieldName: param.parameterName, + dataType: EnumMappings_1.PresLayerToApiEnumMappings.dataType.convert(param.dataType), + currentValue: currentValue, + allowableValuesType: allowableValuesType + }; + if (allowableValuesType === api_internal_contract_1.DomainRestrictionType.List) { + var allowableValues = new Array(); + for (var i = 0; i < param.valuesAliases.length; i++) { + var adv = param.valuesAliases[i]; + var formattedValue = param.formattedValues[i]; + allowableValues.push(ParametersDataConverter.convertAliasedDataValue(adv, formattedValue)); + } + result.allowableValues = allowableValues; + } + else if (allowableValuesType === api_internal_contract_1.DomainRestrictionType.Range) { + result.minValue = ParametersDataConverter.makeDataValue(param.valueMin, param.formattedMin); + result.maxValue = ParametersDataConverter.makeDataValue(param.valueMax, param.formattedMax); + result.stepSize = ParametersDataConverter.convertNumber(result.dataType, param.valueInc); + result.dateStepPeriod = EnumMappings_1.PresLayerToApiEnumMappings.dateStepPeriod.convert(param.datePeriodType, false); + } + else { + // Nothing to do in the case that all values are allowed + } + return result; + }; + ParametersDataConverter.convertNumber = function (dataType, value) { + if (value) { + if (dataType === api_internal_contract_1.DataType.Int || dataType === api_internal_contract_1.DataType.Date || dataType === api_internal_contract_1.DataType.DateTime) { + return parseInt(value, 10); + } + else if (dataType === api_internal_contract_1.DataType.Float) { + return parseFloat(value); + } + } + return undefined; + }; + /*tslint:disable-next-line:no-any */ + ParametersDataConverter.makeDataValue = function (value, formattedValue, alias) { + var result = { + value: value, + formattedValue: formattedValue, + aliasedValue: alias || formattedValue + }; + return result; + }; + /*tslint:disable-next-line:no-any */ + ParametersDataConverter.convertAliasedDataValue = function (adv, formattedValue) { + // AliasedDataValues are serialized in kind of a strange way from the platform code. They are output + // as an array of 2 values. The first is the actual value, the second is the alias. See AliasedDataValueSerializer::ToSerializer + if (!adv || !(adv instanceof Array)) { + throw api_utils_1.TableauException.invalid(['aliased data value']); + } + var value = adv[0]; + var alias = adv.length < 2 ? undefined : adv[1]; + return ParametersDataConverter.makeDataValue(value, formattedValue, alias); + }; + return ParametersDataConverter; + }()); + exports.ParametersDataConverter = ParametersDataConverter; + + +/***/ }, +/* 98 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export(__webpack_require__(4)); + __export(__webpack_require__(5)); + __export(__webpack_require__(6)); + __export(__webpack_require__(7)); + __export(__webpack_require__(8)); + + +/***/ }, +/* 99 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + /** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ + Object.defineProperty(exports, "__esModule", { value: true }); + var EnumConverter_1 = __webpack_require__(14); + exports.EnumConverter = EnumConverter_1.EnumConverter; + var Param_1 = __webpack_require__(16); + exports.Param = Param_1.Param; + var TableauException_1 = __webpack_require__(15); + exports.TableauException = TableauException_1.TableauException; + + +/***/ }, +/* 100 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implemenation of the PresentationLayer contract with a bit of extra information + * added to work with add-ins. Most work is delegated down to the interopObject which + * communicates directly with the c++ layer via QWebChannel + * + * @class AddInApiPresLayerImpl + * @implements {contract.PresentationLayer} + */ + var AddInApiPresLayerImpl = (function () { + function AddInApiPresLayerImpl(_interopObject) { + var _this = this; + this._interopObject = _interopObject; + this._notificationHandlers = {}; + if (_interopObject && _interopObject.OnNotification) { + _interopObject.OnNotification.connect(function (notification) { + _this.dispatchNotification(notification); + }); + } + } + Object.defineProperty(AddInApiPresLayerImpl.prototype, "AddInInstanceInfo", { + /** + * Gets the instance info for this particular add-in from the c++ code + * + * @readonly + * @type {AddInInstancePresModel} + * @memberof AddInApiPresLayerImpl + */ + get: function () { + return this._interopObject.addInInstanceInfo; + }, + enumerable: true, + configurable: true + }); + /** + * Invokes a command using the pres-layer interop + * + * @template T - The expected return type + * @param {string} commandNamespace + * @param {string} commandName + * @param {object} params + * @returns {Promise} + * @memberof AddInApiPresLayerImpl + */ + AddInApiPresLayerImpl.prototype.invokeCommand = function (commandNamespace, commandName, params) { + var _this = this; + return new Promise(function (resolve, reject) { + try { + commandNamespace = commandNamespace || 'tabdoc'; + _this._interopObject.ExecuteCommand(commandNamespace, commandName, params, function (response) { + if (!response.Success) { + var msg = 'ExecuteCommand failed, with result:' + JSON.stringify(response.Result); + reject(new Error(msg)); + } + else { + resolve(response.Result); + } + }); + } + catch (err) { + reject(err); + } + }); + }; + // This implementation will registration a single instance of a notification handler with the Native C++ object, + // and implement multi-dispatch to the web objects from h.ere + AddInApiPresLayerImpl.prototype.registerNotificationHandler = function (eventId, handler) { + var _this = this; + if (eventId in this._notificationHandlers) { + this._notificationHandlers[eventId].push(handler); + } + else { + this._notificationHandlers[eventId] = [handler]; + try { + this._interopObject.RegisterNotificationHandler(eventId); + } + catch (err) { + // console.log('RegisterNotificationHandler failed: ' + err); + } + } + return function () { return _this.removeNotificationHandler(eventId, handler); }; + }; + AddInApiPresLayerImpl.prototype.removeNotificationHandler = function (eventId, handler) { + var handlerList = this._notificationHandlers[eventId]; + if (!handlerList) { + return; + } + var foundIndex = handlerList.indexOf(handler); + if (foundIndex >= 0) { + handlerList.splice(foundIndex, 1); + } + if (handlerList.length === 0) { + delete this._notificationHandlers[eventId]; + } + }; + AddInApiPresLayerImpl.prototype.dispatchNotification = function (notification) { + // console.log('received notification: ' + JSON.stringify(notification)); + var eventId = notification.eventId; + var presModel = notification.presModel; + if (eventId in this._notificationHandlers) { + var handlers = this._notificationHandlers[eventId]; + for (var i = handlers.length - 1; i >= 0; i--) { + handlers[i](presModel); + } + } + }; + return AddInApiPresLayerImpl; + }()); + exports.AddInApiPresLayerImpl = AddInApiPresLayerImpl; + + +/***/ }, +/* 101 */ +/***/ function(module, exports) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * Implementation of the InternalApiDispatcher for desktop. Since this will run in the same + * frame as the ApiEventHandler, this class mostly just marshalls down to that implementation + * + * @export + * @class DesktopApiDispatcher + * @implements {InternalApiDispatcher} + */ + var DesktopApiDispatcher = (function () { + function DesktopApiDispatcher(_apiEventHandler) { + var _this = this; + this._apiEventHandler = _apiEventHandler; + this._notificationHandlers = []; + this._apiEventHandler.setEventHandler(function (notificationId, model) { + _this._notificationHandlers.forEach(function (handler) { return handler({ + notificationId: notificationId, + data: model + }); }); + }); + } + DesktopApiDispatcher.prototype.setVersionNumber = function (versionNumber) { + this._apiEventHandler.setVersionNumber(versionNumber); + }; + DesktopApiDispatcher.prototype.execute = function (verb, parameters) { + // Just pass this right through to the ApiEventHandler + return this._apiEventHandler.execute(verb, parameters); + }; + DesktopApiDispatcher.prototype.registerNotificationHandler = function (handler) { + this._notificationHandlers.push(handler); + }; + DesktopApiDispatcher.prototype.unregisterNotificationHandler = function (handler) { + this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; }); + }; + return DesktopApiDispatcher; + }()); + exports.DesktopApiDispatcher = DesktopApiDispatcher; + + +/***/ }, +/* 102 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + __webpack_require__(103); + var qwebchannel_1 = __webpack_require__(104); + /** + * Initializes the QWebChannel contract and returns the pres layer interop object + * + * @returns {Promise} + */ + function initializeWebChannelPresLayer() { + return new Promise(function (resolve, reject) { + try { + // tslint:disable-next-line + new qwebchannel_1.QWebChannel(qt.webChannelTransport, function (channel) { + // tslint:disable-next-line + var addInPresLayer = channel.objects['addInPresLayer']; + resolve(addInPresLayer); + }); + } + catch (e) { + reject(e); + } + }); + } + exports.initializeWebChannelPresLayer = initializeWebChannelPresLayer; + function hasQt() { + return typeof qt === 'object'; + } + exports.hasQt = hasQt; + + +/***/ }, +/* 103 */ +/***/ function(module, exports) { + + + +/***/ }, +/* 104 */ +/***/ function(module, exports, __webpack_require__) { + + /**************************************************************************** + ** + ** Copyright (C) 2015 The Qt Company Ltd. + ** Copyright (C) 2014 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff + ** Contact: http://www.qt.io/licensing/ + ** + ** This file is part of the QtWebChannel module of the Qt Toolkit. + ** + ** $QT_BEGIN_LICENSE:LGPL21$ + ** Commercial License Usage + ** Licensees holding valid commercial Qt licenses may use this file in + ** accordance with the commercial license agreement provided with the + ** Software or, alternatively, in accordance with the terms contained in + ** a written agreement between you and The Qt Company. For licensing terms + ** and conditions see http://www.qt.io/terms-conditions. For further + ** information use the contact form at http://www.qt.io/contact-us. + ** + ** GNU Lesser General Public License Usage + ** Alternatively, this file may be used under the terms of the GNU Lesser + ** General Public License version 2.1 or version 3 as published by the Free + ** Software Foundation and appearing in the file LICENSE.LGPLv21 and + ** LICENSE.LGPLv3 included in the packaging of this file. Please review the + ** following information to ensure the GNU Lesser General Public License + ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and + ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. + ** + ** As a special exception, The Qt Company gives you certain additional + ** rights. These rights are described in The Qt Company LGPL Exception + ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. + ** + ** $QT_END_LICENSE$ + ** + ****************************************************************************/ + + "use strict"; + + var QWebChannelMessageTypes = { + signal: 1, + propertyUpdate: 2, + init: 3, + idle: 4, + debug: 5, + invokeMethod: 6, + connectToSignal: 7, + disconnectFromSignal: 8, + setProperty: 9, + response: 10, + }; + + var QWebChannel = function(transport, initCallback) + { + if (typeof transport !== "object" || typeof transport.send !== "function") { + console.error("The QWebChannel expects a transport object with a send function and onmessage callback property." + + " Given is: transport: " + typeof(transport) + ", transport.send: " + typeof(transport.send)); + return; + } + + var channel = this; + this.transport = transport; + + this.send = function(data) + { + if (typeof(data) !== "string") { + data = JSON.stringify(data); + } + channel.transport.send(data); + } + + this.transport.onmessage = function(message) + { + var data = message.data; + if (typeof data === "string") { + data = JSON.parse(data); + } + switch (data.type) { + case QWebChannelMessageTypes.signal: + channel.handleSignal(data); + break; + case QWebChannelMessageTypes.response: + channel.handleResponse(data); + break; + case QWebChannelMessageTypes.propertyUpdate: + channel.handlePropertyUpdate(data); + break; + default: + console.error("invalid message received:", message.data); + break; + } + } + + this.execCallbacks = {}; + this.execId = 0; + this.exec = function(data, callback) + { + if (!callback) { + // if no callback is given, send directly + channel.send(data); + return; + } + if (channel.execId === Number.MAX_VALUE) { + // wrap + channel.execId = Number.MIN_VALUE; + } + if (data.hasOwnProperty("id")) { + console.error("Cannot exec message with property id: " + JSON.stringify(data)); + return; + } + data.id = channel.execId++; + channel.execCallbacks[data.id] = callback; + channel.send(data); + }; + + this.objects = {}; + + this.handleSignal = function(message) + { + var object = channel.objects[message.object]; + if (object) { + object.signalEmitted(message.signal, message.args); + } else { + console.warn("Unhandled signal: " + message.object + "::" + message.signal); + } + } + + this.handleResponse = function(message) + { + if (!message.hasOwnProperty("id")) { + console.error("Invalid response message received: ", JSON.stringify(message)); + return; + } + channel.execCallbacks[message.id](message.data); + delete channel.execCallbacks[message.id]; + } + + this.handlePropertyUpdate = function(message) + { + for (var i in message.data) { + var data = message.data[i]; + var object = channel.objects[data.object]; + if (object) { + object.propertyUpdate(data.signals, data.properties); + } else { + console.warn("Unhandled property update: " + data.object + "::" + data.signal); + } + } + channel.exec({type: QWebChannelMessageTypes.idle}); + } + + this.debug = function(message) + { + channel.send({type: QWebChannelMessageTypes.debug, data: message}); + }; + + channel.exec({type: QWebChannelMessageTypes.init}, function(data) { + for (var objectName in data) { + var object = new QObject(objectName, data[objectName], channel); + } + // now unwrap properties, which might reference other registered objects + for (var objectName in channel.objects) { + channel.objects[objectName].unwrapProperties(); + } + if (initCallback) { + initCallback(channel); + } + channel.exec({type: QWebChannelMessageTypes.idle}); + }); + }; + + function QObject(name, data, webChannel) + { + this.__id__ = name; + webChannel.objects[name] = this; + + // List of callbacks that get invoked upon signal emission + this.__objectSignals__ = {}; + + // Cache of all properties, updated when a notify signal is emitted + this.__propertyCache__ = {}; + + var object = this; + + // ---------------------------------------------------------------------- + + this.unwrapQObject = function(response) + { + if (response instanceof Array) { + // support list of objects + var ret = new Array(response.length); + for (var i = 0; i < response.length; ++i) { + ret[i] = object.unwrapQObject(response[i]); + } + return ret; + } + if (!response + || !response["__QObject*__"] + || response["id"] === undefined) { + return response; + } + + var objectId = response.id; + if (webChannel.objects[objectId]) + return webChannel.objects[objectId]; + + if (!response.data) { + console.error("Cannot unwrap unknown QObject " + objectId + " without data."); + return; + } + + var qObject = new QObject( objectId, response.data, webChannel ); + qObject.destroyed.connect(function() { + if (webChannel.objects[objectId] === qObject) { + delete webChannel.objects[objectId]; + // reset the now deleted QObject to an empty {} object + // just assigning {} though would not have the desired effect, but the + // below also ensures all external references will see the empty map + // NOTE: this detour is necessary to workaround QTBUG-40021 + var propertyNames = []; + for (var propertyName in qObject) { + propertyNames.push(propertyName); + } + for (var idx in propertyNames) { + delete qObject[propertyNames[idx]]; + } + } + }); + // here we are already initialized, and thus must directly unwrap the properties + qObject.unwrapProperties(); + return qObject; + } + + this.unwrapProperties = function() + { + for (var propertyIdx in object.__propertyCache__) { + object.__propertyCache__[propertyIdx] = object.unwrapQObject(object.__propertyCache__[propertyIdx]); + } + } + + function addSignal(signalData, isPropertyNotifySignal) + { + var signalName = signalData[0]; + var signalIndex = signalData[1]; + object[signalName] = { + connect: function(callback) { + if (typeof(callback) !== "function") { + console.error("Bad callback given to connect to signal " + signalName); + return; + } + + object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || []; + object.__objectSignals__[signalIndex].push(callback); + + if (!isPropertyNotifySignal && signalName !== "destroyed") { + // only required for "pure" signals, handled separately for properties in propertyUpdate + // also note that we always get notified about the destroyed signal + webChannel.exec({ + type: QWebChannelMessageTypes.connectToSignal, + object: object.__id__, + signal: signalIndex + }); + } + }, + disconnect: function(callback) { + if (typeof(callback) !== "function") { + console.error("Bad callback given to disconnect from signal " + signalName); + return; + } + object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || []; + var idx = object.__objectSignals__[signalIndex].indexOf(callback); + if (idx === -1) { + console.error("Cannot find connection of signal " + signalName + " to " + callback.name); + return; + } + object.__objectSignals__[signalIndex].splice(idx, 1); + if (!isPropertyNotifySignal && object.__objectSignals__[signalIndex].length === 0) { + // only required for "pure" signals, handled separately for properties in propertyUpdate + webChannel.exec({ + type: QWebChannelMessageTypes.disconnectFromSignal, + object: object.__id__, + signal: signalIndex + }); + } + } + }; + } + + /** + * Invokes all callbacks for the given signalname. Also works for property notify callbacks. + */ + function invokeSignalCallbacks(signalName, signalArgs) + { + var connections = object.__objectSignals__[signalName]; + if (connections) { + connections.forEach(function(callback) { + callback.apply(callback, signalArgs); + }); + } + } + + this.propertyUpdate = function(signals, propertyMap) + { + // update property cache + for (var propertyIndex in propertyMap) { + var propertyValue = propertyMap[propertyIndex]; + object.__propertyCache__[propertyIndex] = propertyValue; + } + + for (var signalName in signals) { + // Invoke all callbacks, as signalEmitted() does not. This ensures the + // property cache is updated before the callbacks are invoked. + invokeSignalCallbacks(signalName, signals[signalName]); + } + } + + this.signalEmitted = function(signalName, signalArgs) + { + invokeSignalCallbacks(signalName, signalArgs); + } + + function addMethod(methodData) + { + var methodName = methodData[0]; + var methodIdx = methodData[1]; + object[methodName] = function() { + var args = []; + var callback; + for (var i = 0; i < arguments.length; ++i) { + if (typeof arguments[i] === "function") + callback = arguments[i]; + else + args.push(arguments[i]); + } + + webChannel.exec({ + "type": QWebChannelMessageTypes.invokeMethod, + "object": object.__id__, + "method": methodIdx, + "args": args + }, function(response) { + if (response !== undefined) { + var result = object.unwrapQObject(response); + if (callback) { + (callback)(result); + } + } + }); + }; + } + + function bindGetterSetter(propertyInfo) + { + var propertyIndex = propertyInfo[0]; + var propertyName = propertyInfo[1]; + var notifySignalData = propertyInfo[2]; + // initialize property cache with current value + // NOTE: if this is an object, it is not directly unwrapped as it might + // reference other QObject that we do not know yet + object.__propertyCache__[propertyIndex] = propertyInfo[3]; + + if (notifySignalData) { + if (notifySignalData[0] === 1) { + // signal name is optimized away, reconstruct the actual name + notifySignalData[0] = propertyName + "Changed"; + } + addSignal(notifySignalData, true); + } + + Object.defineProperty(object, propertyName, { + get: function () { + var propertyValue = object.__propertyCache__[propertyIndex]; + if (propertyValue === undefined) { + // This shouldn't happen + console.warn("Undefined value in property cache for property \"" + propertyName + "\" in object " + object.__id__); + } + + return propertyValue; + }, + set: function(value) { + if (value === undefined) { + console.warn("Property setter for " + propertyName + " called with undefined value!"); + return; + } + object.__propertyCache__[propertyIndex] = value; + webChannel.exec({ + "type": QWebChannelMessageTypes.setProperty, + "object": object.__id__, + "property": propertyIndex, + "value": value + }); + } + }); + + } + + // ---------------------------------------------------------------------- + + data.methods.forEach(addMethod); + + data.properties.forEach(bindGetterSetter); + + data.signals.forEach(function(signal) { addSignal(signal, false); }); + + for (var name in data.enums) { + object[name] = data.enums[name]; + } + } + + //required for use with nodejs + if (true) { + module.exports = { + QWebChannel: QWebChannel + }; + } + + +/***/ } +/******/ ]) +}); +; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 8d7f1cb9b760473b56c6","webpack:///../src/Main.ts","webpack:///D:/dev/js-api/extensions-api/src/ExtensionsApi.ts","webpack:///D:/dev/js-api/extensions-api/src/Impl/ExtensionsImpl.ts","webpack:///D:/dev/js-api/api-internal-contract/src/ApiInternalContract.ts","webpack:///D:/dev/js-api/api-internal-contract/src/interface/Enums.ts","webpack:///D:/dev/js-api/api-internal-contract/src/interface/InternalApiDispatcher.ts","webpack:///D:/dev/js-api/api-internal-contract/src/interface/Notifications.ts","webpack:///D:/dev/js-api/api-internal-contract/src/interface/Parameters.ts","webpack:///D:/dev/js-api/api-internal-contract/src/interface/Verbs.ts","webpack:///D:/dev/js-api/api-shared/src/ApiShared.ts","webpack:///D:/dev/js-api/api-shared/src/Dashboard.ts","webpack:///D:/dev/js-api/api-shared/src/Sheet.ts","webpack:///D:/dev/js-api/api-shared/src/EventListenerManager.ts","webpack:///D:/dev/js-api/api-utils/src/ApiUtils.ts","webpack:///D:/dev/js-api/api-utils/src/EnumConverter.ts","webpack:///D:/dev/js-api/api-utils/src/TableauException.ts","webpack:///D:/dev/js-api/api-utils/src/Param.ts","webpack:///D:/dev/js-api/api-shared/src/VersionNumber.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/DashboardImpl.ts","webpack:///D:/dev/js-api/api-external-contract/src/ApiExternalContract.ts","webpack:///D:/dev/js-api/api-external-contract/src/Enums.ts","webpack:///D:/dev/js-api/api-shared/src/DashboardObject.ts","webpack:///D:/dev/js-api/api-shared/src/EnumMappings/InternalToExternalEnumMappings.ts","webpack:///D:/dev/js-api/api-shared/src/Point.ts","webpack:///D:/dev/js-api/api-shared/src/Size.ts","webpack:///D:/dev/js-api/api-shared/src/Worksheet.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/SheetImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Services/ServiceRegistry.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/SheetInfoImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/WorksheetImpl.ts","webpack:///D:/dev/js-api/api-shared/src/DataSource.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/DataSourceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/FieldImpl.ts","webpack:///D:/dev/js-api/api-shared/src/ConnectionSummary.ts","webpack:///D:/dev/js-api/api-shared/src/Field.ts","webpack:///D:/dev/js-api/api-shared/src/TableSummary.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/SingleEventManagerImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Events/FilterChangedEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Events/TableauWorksheetEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Events/TableauSheetEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Events/TableauEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Events/MarksSelectedEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Services/GetDataService.ts","webpack:///D:/dev/js-api/api-shared/src/Services/RegisterAllSharedServices.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/DataSourceServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/FilterServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/EnumMappings/ExternalToInternalEnumMappings.ts","webpack:///D:/dev/js-api/api-shared/src/Models/FilterModels.ts","webpack:///D:/dev/js-api/api-shared/src/Models/GetDataModels.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/GetDataServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/NotificationServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/ParametersServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Impl/ParameterImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Events/ParameterChangedEvent.ts","webpack:///D:/dev/js-api/api-shared/src/Parameter.ts","webpack:///D:/dev/js-api/api-shared/src/Services/impl/SelectionServiceImpl.ts","webpack:///D:/dev/js-api/api-shared/src/Models/SelectionModels.ts","webpack:///D:/dev/js-api/api-shared/src/CrossFrame/CrossFrameBootstrap.ts","webpack:///D:/dev/js-api/api-messaging/src/ApiMessaging.ts","webpack:///D:/dev/js-api/api-messaging/src/CrossFrameMessenger.ts","webpack:///../src/Guid.ts","webpack:///D:/dev/js-api/api-messaging/src/CrossFramePreparedMessage.ts","webpack:///D:/dev/js-api/api-messaging/src/interface/MessageTypes.ts","webpack:///D:/dev/js-api/api-messaging/src/MessageTypeChecks.ts","webpack:///D:/dev/js-api/api-shared/src/CrossFrame/CrossFrameDispatcher.ts","webpack:///D:/dev/js-api/extensions-api/src/Namespaces/DashboardContent.ts","webpack:///D:/dev/js-api/extensions-api/src/Namespaces/Environment.ts","webpack:///D:/dev/js-api/extensions-api/src/Namespaces/Settings.ts","webpack:///D:/dev/js-api/extensions-api/src/Services/RegisterAllExtensionsServices.ts","webpack:///D:/dev/js-api/extensions-api/src/Services/Impl/InitializationServiceImpl.ts","webpack:///D:/dev/js-api/extensions-api/src/Services/Impl/SettingsServiceImpl.ts","webpack:///D:/dev/js-api/extensions-api/src/Impl/SettingsImpl.ts","webpack:///D:/dev/js-api/extensions-api/src/Namespaces/Extensions.ts","webpack:///../src/FrelardDesktopBootstrap.ts","webpack:///D:/dev/js-api/api-core/src/ApiCore.ts","webpack:///D:/dev/js-api/api-core/src/ApiEventHandler.ts","webpack:///D:/dev/js-api/api-core/gen-src/preslayer/Params.ts","webpack:///D:/dev/js-api/api-core/src/mappings/CommandMappingRegistryFactory.ts","webpack:///D:/dev/js-api/api-core/gen-src/preslayer/CommandIds.ts","webpack:///D:/dev/js-api/api-core/src/mappings/CommandMappingRegistry.ts","webpack:///D:/dev/js-api/api-core/src/mappings/CommandRegistration.ts","webpack:///D:/dev/js-api/api-core/src/mappings/EventMappingRegistryFactory.ts","webpack:///D:/dev/js-api/api-core/gen-src/preslayer/Events.ts","webpack:///D:/dev/js-api/api-core/src/mappings/PresLayerToApiConverter.ts","webpack:///D:/dev/js-api/api-core/src/mappings/EnumMappings.ts","webpack:///D:/dev/js-api/api-core/gen-src/preslayer/Enums.ts","webpack:///D:/dev/js-api/api-core/src/mappings/ParameterMappingRegistryFactory.ts","webpack:///D:/dev/js-api/api-core/src/mappings/ActiveMarksDataConverter.ts","webpack:///D:/dev/js-api/api-core/src/mappings/UnderlyingDataConverter.ts","webpack:///D:/dev/js-api/api-core/src/mappings/ApiToPresLayerConverter.ts","webpack:///D:/dev/js-api/api-core/src/mappings/FiltersConverter.ts","webpack:///D:/dev/js-api/api-core/src/mappings/MappingRegistry.ts","webpack:///D:/dev/js-api/api-core/src/mappings/ParametersDataConverter.ts","webpack:///../src/AddInApiPresLayerImpl.ts","webpack:///../src/DesktopApiDispatcher.ts","webpack:///../src/QtWebChannelImpl.ts","webpack:///../~/qwebchannel/qwebchannel.js"],"names":[],"mappings":"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CAAC,CAAC;SACZ,CAAC;KACH,CAAC,CAAC,CAAC;AACL,EAAC;AAfD,uEAeC;AAED;KACE,MAAM,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC;AAChC,EAAC;AAFD,uBAEC;;;;;;;;;;;;;AC9BD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;AACA;AACA,uBAAsB,mCAAmC;AACzD;;AAEA;AACA;AACA,uBAAsB,mDAAmD;AACzE;;AAEA,mBAAkB,mCAAmC;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAsB,mCAAmC;AACzD,MAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,4BAA2B,qBAAqB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gEAA+D;AAC/D,qCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB;AACrB;AACA,cAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA2B,sBAAsB;AACjD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,cAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAiB;AACjB;AACA,UAAS;;AAET;;AAEA;;AAEA;;AAEA;;AAEA,4CAA2C,0BAA0B,EAAE;;AAEvE;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA","file":"frelard-desktop-bootstrap.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Main\"] = factory();\n\telse\n\t\troot[\"Main\"] = factory();\n})(this, function() {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/dist/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 8d7f1cb9b760473b56c6\n **/","import * as tableau from '@tableau/extensions-api';\r\n\r\nimport { doBootstrap } from './FrelardDesktopBootstrap';\r\n\r\n// This Main function will be executed when this module is loaded. Attempt to do our\r\n// bootstrapping with qt and log any errors we encounter\r\ndoBootstrap().catch(e => {\r\n  console.log('Desktop bootstrapping failed: ' + e);\r\n});\r\n\r\n// Declare the imported tableau object on the global namespace\r\n// (This must go away once we don't import at the API ourselves)\r\ndeclare global  {\r\n  interface Window {\r\n    /*tslint:disable-next-line:no-any */\r\n    tableau: any;\r\n  }\r\n}\r\n\r\nwindow.tableau = tableau;\r\n\n\n\n/** WEBPACK FOOTER **\n ** ../src/Main.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\n// Due to the way we configured webpack, we should be exporting things which will be under\r\n// a global variable called \"tableau\". Export everything we want to be visible under tableau\r\n// from this file.\r\n\r\nimport { ExtensionsImpl } from './Impl/ExtensionsImpl';\r\nimport { Extensions } from './Namespaces/Extensions';\r\n\r\nimport { VersionNumber } from '@tableau/api-shared';\r\n\r\ndeclare var EXTENSION_API_VERSION_NUMBER: string;\r\nVersionNumber.SetVersionNumber(EXTENSION_API_VERSION_NUMBER);\r\n\r\nconst extensionImpl = new ExtensionsImpl();\r\nexport const extensions = new Extensions(extensionImpl);\r\n\r\n// Export Enums\r\n// These show up under the tableau object. I.e. tableau.ExtensionContext.Server\r\nexport {\r\n  ExtensionContext,\r\n  ExtensionMode,\r\n  AnalyticsObjectType,\r\n  ColumnType,\r\n  DashboardObjectType,\r\n  DataType,\r\n  DateRangeType,\r\n  DialogEventType,\r\n  EncodingType,\r\n  ErrorCodes,\r\n  FieldAggregationType,\r\n  FieldRoleType,\r\n  FilterDomainType,\r\n  FilterType,\r\n  FilterUpdateType,\r\n  FilterNullOption,\r\n  MarkType,\r\n  ParameterValueType,\r\n  PeriodType,\r\n  QuickTableCalcType,\r\n  SelectionUpdateType,\r\n  SheetType,\r\n  SortDirection,\r\n  TableauEventType,\r\n  TrendLineModelType\r\n} from '@tableau/api-external-contract';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/ExtensionsApi.ts\n **/","import {\r\n  ExtensionDashboardInfo,\r\n  ExtensionSettingsInfo,\r\n  InternalApiDispatcher,\r\n  InternalApiDispatcherHolder,\r\n  SheetPath,\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport {\r\n  ApiServiceRegistry,\r\n  Dashboard,\r\n  DashboardImpl,\r\n  doCrossFrameBootstrap,\r\n  registerAllSharedServices,\r\n  VersionNumber\r\n} from '@tableau/api-shared';\r\n\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { DashboardContent } from '../Namespaces/DashboardContent';\r\nimport { Environment } from '../Namespaces/Environment';\r\nimport { Settings } from '../Namespaces/Settings';\r\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\r\nimport { InitializationService } from '../Services/InitializationService';\r\nimport { registerAllExtensionsServices } from '../Services/RegisterAllExtensionsServices';\r\nimport { SettingsImpl } from './SettingsImpl';\r\n\r\nexport class ExtensionsImpl {\r\n  private _initializationPromise: Promise<void>;\r\n\r\n  public dashboardContent: DashboardContent;\r\n  public environment: Environment;\r\n  public settings: Settings;\r\n\r\n  public initializeAsync(): Promise<void> {\r\n    if (!this._initializationPromise) {\r\n      this._initializationPromise = new Promise<void>((resolve, reject) => {\r\n        // First thing we want to do is check to see if there is a desktop dispatcher already registered for us\r\n        if (InternalApiDispatcherHolder.hasDesktopApiDispatcherPromise()) {\r\n          // Running in desktop, use this promise\r\n          const desktopDispatcherPromise = InternalApiDispatcherHolder.getDesktopDispatcherPromise();\r\n          desktopDispatcherPromise.then(this.onDispatcherReceived.bind(this)).then(() => { resolve(); });\r\n        } else {\r\n          // We must be running in server, so we should try to kick of the server dispatcher bootstrapping\r\n          doCrossFrameBootstrap(window, VersionNumber.Instance).then(this.onDispatcherReceived.bind(this)).then(() => { resolve(); });\r\n        }\r\n      });\r\n    }\r\n\r\n    return this._initializationPromise;\r\n  }\r\n\r\n  private onDispatcherReceived(dispatcher: InternalApiDispatcher): Promise<void> {\r\n    dispatcher.setVersionNumber(VersionNumber.Instance);\r\n\r\n    // Call to register all the services which will use the newly initialized dispatcher\r\n    registerAllSharedServices(dispatcher);\r\n    registerAllExtensionsServices(dispatcher);\r\n\r\n    // Get the initialization service and initialize this extension\r\n    const initializationService = ApiServiceRegistry.instance.getService<InitializationService>(\r\n      ExtensionsServiceNames.InitializationService);\r\n\r\n    return initializationService.initializeDashboardExtensionsAsync().then(result => {\r\n      if (!result.extensionInstance.locator.dashboardPath) {\r\n        throw TableauException.isUndefined(['DashboardPath']);\r\n      }\r\n\r\n      this.dashboardContent = this.initializeDashboardContent(result.extensionDashboardInfo,\r\n                                                              result.extensionInstance.locator.dashboardPath);\r\n      this.environment = new Environment(result.extensionEnvironment);\r\n      this.settings = this.initializeSettings(result.extensionSettingsInfo);\r\n    });\r\n  }\r\n\r\n  private initializeDashboardContent(info: ExtensionDashboardInfo, sheetPath: SheetPath): DashboardContent {\r\n    const dashboardImpl = new DashboardImpl(info, sheetPath);\r\n    const dashboard = new Dashboard(dashboardImpl);\r\n    return new DashboardContent(dashboard);\r\n  }\r\n\r\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): Settings {\r\n    const settingsImpl = new SettingsImpl(settingsInfo);\r\n    return new Settings(settingsImpl);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Impl/ExtensionsImpl.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport * from './interface/Enums';\r\nexport * from './interface/InternalApiDispatcher';\r\nexport * from './interface/Models';\r\nexport * from './interface/Notifications';\r\nexport * from './interface/Parameters';\r\nexport * from './interface/Verbs';\r\nexport * from './interface/VersionNumber';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/ApiInternalContract.ts\n **/","export enum ExtensionContext {\r\n  Desktop = 'desktop',\r\n  Server = 'server',\r\n  Unknown = 'unknown'\r\n}\r\n\r\nexport enum ExtensionMode {\r\n  Authoring = 'authoring',\r\n  Viewing = 'viewing',\r\n  Unknown = 'unknown'\r\n}\r\n\r\nexport enum ColumnType {\r\n  Discrete = 'discrete',\r\n  Continuous = 'continuous'\r\n}\r\n\r\nexport enum DashboardObjectType {\r\n  Blank = 'blank',\r\n  Worksheet = 'worksheet',\r\n  QuickFilter = 'quick-filter',\r\n  ParameterControl = 'parameter-control',\r\n  PageFilter = 'page-filter',\r\n  Legend = 'legend',\r\n  Title = 'title',\r\n  Text = 'text',\r\n  Image = 'image',\r\n  WebPage = 'web-page',\r\n  Extension = 'extension'\r\n}\r\n\r\nexport enum DataType {\r\n  String = 'string',\r\n  Int = 'int',\r\n  Float = 'float',\r\n  Bool = 'bool',\r\n  Date = 'date',\r\n  DateTime = 'date-time',\r\n  Spatial = 'spatial'\r\n}\r\n\r\nexport enum EncodedDataType {\r\n  Number = 'number',\r\n  String = 'string',\r\n  Date = 'date',\r\n  Boolean = 'boolean'\r\n}\r\n\r\nexport enum ErrorCode {\r\n  ServerError = 'server-error',\r\n  InvalidAggregationFieldName = 'invalid-aggregation-field-name',\r\n  InvalidFilterFieldName = 'invalid-filter-fieldname',\r\n  InvalidFilterFieldValue = 'invalid-filter-field-value'\r\n}\r\n\r\nexport enum FieldAggregationType {\r\n  Sum = 'sum',\r\n  Avg = 'avg',\r\n  Min = 'min',\r\n  Max = 'max',\r\n  Stdev = 'stdev',\r\n  Stdevp = 'stdevp',\r\n  Var = 'var',\r\n  Varp = 'varp',\r\n  Count = 'count',\r\n  Countd = 'countd',\r\n  Median = 'median',\r\n  Attr = 'attr',\r\n  None = 'none',\r\n  Year = 'year',\r\n  Qtr = 'qtr',\r\n  Month = 'month',\r\n  Day = 'day',\r\n  Hour = 'hour',\r\n  Minute = 'minute',\r\n  Second = 'second',\r\n  Week = 'week',\r\n  Weekday = 'weekday',\r\n  MonthYear = 'month-year',\r\n  Mdy = 'mdy',\r\n  End = 'end',\r\n  TruncYear = 'trunc-year',\r\n  TruncQtr = 'trunc-qtr',\r\n  TruncMonth = 'trunc-month',\r\n  TruncWeek = 'trunc-week',\r\n  TruncDay = 'trunc-day',\r\n  TruncHour = 'trunc-hour',\r\n  TruncMinute = 'trunc-minute',\r\n  TruncSecond = 'trunc-second',\r\n  Quart1 = 'quart1',\r\n  Quart3 = 'quart3',\r\n  Skewness = 'skewness',\r\n  Kurtosis = 'kurtosis',\r\n  InOut = 'in-out',\r\n  User = 'user'\r\n}\r\n\r\nexport enum FieldRoleType {\r\n  Dimension = 'dimension',\r\n  Measure = 'measure',\r\n  Unknown = 'unknown'\r\n}\r\n\r\n/**\r\n *  The different update types for applying filter.\r\n */\r\nexport enum FilterUpdateType {\r\n  Add = 'add',\r\n  All = 'all',\r\n  Replace = 'replace',\r\n  Remove = 'remove'\r\n}\r\n\r\nexport enum SheetType {\r\n  Dashboard = 'dashboard',\r\n  Story = 'story',\r\n  Worksheet = 'worksheet'\r\n}\r\n\r\nexport enum DomainRestrictionType {\r\n  All = 'all',\r\n  List = 'list',\r\n  Range = 'range'\r\n}\r\n\r\nexport enum DateStepPeriod {\r\n  Years = 'years',\r\n  Quarters = 'quarters',\r\n  Months = 'months',\r\n  Weeks = 'weeks',\r\n  Days = 'days',\r\n  Hours = 'hours',\r\n  Minutes = 'minutes',\r\n  Seconds = 'seconds'\r\n}\r\n\r\n/**\r\n * The option for specifying which values to include for filtering.\r\n */\r\nexport enum FilterNullOption {\r\n  NullValues = 'nullvalues',\r\n  NonNullValues = 'nonnullvalues',\r\n  AllValues = 'allvalues'\r\n}\r\n\r\n/**\r\n * The type of filter domain\r\n */\r\nexport enum FilterDomainType {\r\n  Relevant = 'relevant',\r\n  Database = 'database'\r\n}\r\n\r\n/**\r\n * Internal enum for specifying the selection type for select marks api.\r\n */\r\nexport enum SelectionUpdateType {\r\n  Replace = 'select-replace',\r\n  Add = 'select-add',\r\n  Remove = 'select-remove'\r\n}\r\n\r\n/**\r\n * Internal enum for specifying the included values type for range selection.\r\n */\r\nexport enum QuantitativeIncludedValues {\r\n  IncludeNull = 'include-null',\r\n  IncludeNonNull = 'include-non-null',\r\n  IncludeAll = 'include-all'\r\n}\r\n\r\n/**\r\n * Type of mark for a given marks card in a viz.\r\n */\r\nexport enum MarkType {\r\n    Bar = 'bar',\r\n    Line = 'line',\r\n    Area = 'area',\r\n    Square = 'square',\r\n    Circle = 'circle',\r\n    Shape = 'shape',\r\n    Text = 'text',\r\n    Map = 'map',\r\n    Pie = 'pie',\r\n    GanttBar = 'gantt-bar',\r\n    Polygon = 'polygon',\r\n}\r\n\r\n/**\r\n * Internal enum for specifying the type of filter\r\n */\r\nexport enum FilterType {\r\n  Categorical = 'categorical',\r\n  Range = 'range',\r\n  RelativeDate = 'relativeDate',\r\n  Hierarchical = 'hierarchical'\r\n}\r\n\r\n/**\r\n * Internal enum for specifying the DateRangeType of a relative date filter\r\n */\r\nexport enum DateRangeType {\r\n  /**\r\n   * Refers to the last day, week, month, etc. of the date period.\r\n   */\r\n  Last = 'last',\r\n  /**\r\n   * Refers to the last N days, weeks, months, etc. of the date period.\r\n   */\r\n  LastN = 'lastN',\r\n  /**\r\n   * Refers to the next day, week, month, etc. of the date period.\r\n   */\r\n  Next = 'next',\r\n  /**\r\n   * Refers to the next N days, weeks, months, etc. of the date period.\r\n   */\r\n  NextN = 'nextN',\r\n  /**\r\n   * Refers to the current day, week, month, etc. of the date period.\r\n   */\r\n  Current = 'current',\r\n  /**\r\n   * Refers to everything up to and including the current day, week, month, etc. of the date period.\r\n   */\r\n  ToDate = 'toDate'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/interface/Enums.ts\n **/","import { Model } from './Models';\r\nimport { NotificationId } from './Notifications';\r\nimport { VerbId } from './Verbs';\r\nimport { VersionNumber } from './VersionNumber';\r\n\r\nexport type NotificationHandler = (notification: Notification) => void;\r\n\r\nexport interface ExecuteParameters {\r\n  [key: string]: Model;\r\n}\r\n\r\nexport interface ExecuteResponse {\r\n  result: Model;\r\n}\r\n\r\nexport interface Notification {\r\n  notificationId: NotificationId;\r\n  data: Model;\r\n}\r\n\r\nexport interface InternalApiDispatcher {\r\n  setVersionNumber(versionNumber: VersionNumber): void;\r\n  execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse>;\r\n  registerNotificationHandler(handler: NotificationHandler): void;\r\n  unregisterNotificationHandler(handler: NotificationHandler): void;\r\n}\r\n\r\ndeclare global {\r\n  interface Window { __tableauDesktopDispatcher: Promise<InternalApiDispatcher>; }\r\n}\r\n\r\nexport namespace InternalApiDispatcherHolder {\r\n  export function getDesktopDispatcherPromise(): Promise<InternalApiDispatcher> {\r\n    return window.__tableauDesktopDispatcher;\r\n  }\r\n\r\n  export function hasDesktopApiDispatcherPromise(): boolean {\r\n    return !!InternalApiDispatcherHolder.getDesktopDispatcherPromise();\r\n  }\r\n\r\n  export function setDesktopDispatcherPromise(dispatcher: Promise<InternalApiDispatcher>): void {\r\n    window.__tableauDesktopDispatcher = dispatcher;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/interface/InternalApiDispatcher.ts\n **/","export enum NotificationId {\r\n  SelectedMarksChanged = 'selected-marks-changed',\r\n  ParameterChanged = 'parameter-changed',\r\n  FilterChanged = 'filter-changed'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/interface/Notifications.ts\n **/","export enum ParameterId {\r\n  ExtensionLocator = 'extension-locator',\r\n  ExtensionBootstrapInfo = 'extension-bootstrap-info',\r\n  ExtensionSettingsInfo = 'extension-settings-info',\r\n  VisualId = 'visual-id',\r\n  SheetPath = 'sheet-path',\r\n  IgnoreAliases = 'ignore-aliases',\r\n  IgnoreSelection = 'ignore-selection',\r\n  IncludeAllColumns = 'include-all-columns',\r\n  MaxRows = 'max-rows',\r\n  UnderlyingDataTable = 'underlying-data-table',\r\n  UnderlyingSummaryDataTable = 'underlying-summary-data-table',\r\n  DataSourceDataTable = 'data-source-data-table',\r\n  SettingsValues = 'settings-values',\r\n  SelectedData = 'selected-data',\r\n  HighlightedData = 'highlighted-data',\r\n\r\n   // Filter Params\r\n  FieldName = 'field-name',\r\n  FilterValues = 'filter-values',\r\n  FilterUpdateType = 'filter-update-type',\r\n  IsExcludeMode = 'is-exclude',\r\n  FilterRangeMin = 'filter-range-min',\r\n  FilterRangeMax = 'filter-range-max',\r\n  FilterRangeNullOption = 'filter-range-null-option',\r\n  WorksheetFilters = 'worksheet-filters',\r\n  FieldId = 'field-id',\r\n  DomainType = 'domain-type',\r\n  CategoricalDomain = 'categorical-domain',\r\n  QuantitativeDomain = 'quantitative-dmain',\r\n\r\n  WorksheetName = 'worksheet-name',\r\n  DashboardName = 'dashboard',\r\n\r\n  ParameterInfo = 'parameter-info',\r\n  ParameterInfos = 'parameter-infos',\r\n  ParameterCaption = 'paremeter-caption',\r\n  ParameterFieldName = 'parameter-field-name',\r\n  ParameterValue = 'parameter-value',\r\n  Selection = 'selection',\r\n  SelectionUpdateType = 'selectionUpdateType',\r\n  HierValSelectionModels = 'hierarchicalValueSelectionModels',\r\n  QuantRangeSelectionModels = 'quantativeRangeSelectionModels',\r\n  DimValSelectionModels = 'dimensionValueSelectionModels',\r\n\r\n  DataSourceId = 'data-source-id',\r\n  DataSchema = 'data-schema',\r\n  DataSourceName = 'data-source-name',\r\n  ColumnsToInclude = 'columns-to-include',\r\n  JoinDescription = 'join-description',\r\n  ConnectionDescriptionSummaries = 'connection-description-summaries',\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/interface/Parameters.ts\n **/","// Declare this key type and export the NotificationId to make this behave like a string enum\r\nexport enum VerbId {\r\n  ApplyCategoricalFilter = 'categorical-filter',\r\n  ApplyRangeFilter = 'range-filter',\r\n  ClearFilter = 'clear-filter',\r\n  InitializeExtension = 'initialize-extension',\r\n  GetDataSummaryData = 'get-summary-data',\r\n  GetUnderlyingData = 'get-underlying-data',\r\n  GetDataSourceData = 'get-datasource-data',\r\n  SaveExtensionSettings = 'save-extension-settings',\r\n  GetSelectedMarks = 'get-selected-marks',\r\n  GetHighlightedMarks = 'get-highlighted-marks',\r\n  GetParametersForSheet = 'get-parameters-for-sheet',\r\n  FindParameter = 'find-parameter',\r\n  ChangeParameterValue = 'change-parameter-value',\r\n  ClearSelectedMarks = 'clear-selected-marks',\r\n  SelectByValue = 'select-by-value',\r\n  GetDataSources = 'get-data-sources',\r\n  RefreshDataSource = 'refresh-data-source',\r\n  GetFilters = 'get-filters',\r\n  GetCategoricalDomain = 'get-categorical-domain',\r\n  GetRangeDomain = 'get-range-domain',\r\n  GetJoinDescription = 'get-join-description',\r\n  GetConnectionDescriptionSummaries = 'get-connection-description-summaries',\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-internal-contract/src/interface/Verbs.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport { Dashboard } from './Dashboard';\r\nexport { VersionNumber } from './VersionNumber';\r\n\r\nexport { DashboardImpl } from './Impl/DashboardImpl';\r\n\r\nexport { InternalToExternalEnumMappings } from './EnumMappings/InternalToExternalEnumMappings';\r\n\r\nexport * from './Services/RegisterAllSharedServices';\r\nexport * from './Services/ServiceRegistry';\r\n\r\nexport * from './CrossFrame/CrossFrameBootstrap';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/ApiShared.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { DashboardImpl } from './Impl/DashboardImpl';\r\nimport { Sheet } from './Sheet';\r\n\r\nexport class Dashboard extends Sheet implements Contract.Dashboard {\r\n  public constructor(private _dashboardImpl: DashboardImpl) {\r\n    super(_dashboardImpl);\r\n    _dashboardImpl.initializeWithPublicInterfaces(this);\r\n  }\r\n\r\n  public get worksheets(): Array<Contract.Worksheet> {\r\n    return this._dashboardImpl.worksheets;\r\n  }\r\n\r\n  public get objects(): Array<Contract.DashboardObject> {\r\n    return this._dashboardImpl.objects;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Dashboard.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { EventListenerManager } from './EventListenerManager';\r\n\r\nimport { SheetImpl } from './Impl/SheetImpl';\r\n\r\nexport class Sheet extends EventListenerManager implements Contract.Sheet {\r\n  public constructor(private _sheetImpl: SheetImpl) {\r\n    super();\r\n  }\r\n\r\n  public get name(): string {\r\n    return this._sheetImpl.name;\r\n  }\r\n\r\n  public get sheetType(): Contract.SheetType {\r\n    return this._sheetImpl.sheetType;\r\n  }\r\n\r\n  public get size(): Contract.Size {\r\n    return this._sheetImpl.size;\r\n  }\r\n\r\n  public findParameterAsync(parameterName: string): Promise<Contract.Parameter | undefined> {\r\n    return this._sheetImpl.findParameterAsync(parameterName, this);\r\n  }\r\n\r\n  public getParametersAsync(): Promise<Array<Contract.Parameter>> {\r\n    return this._sheetImpl.getParametersAsync(this);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Sheet.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { SingleEventManager } from './SingleEventManager';\r\n\r\n/**\r\n * Class designed to register and unregister handlers from a user. Only those events\r\n * which are added via AddNewEventType will be supported by this instance\r\n */\r\nexport class EventListenerManager implements  Contract.EventListenerManager {\r\n  private static UNSUPPORTED_EVENT: string = 'Unsupported event type : %1';\r\n  private _eventListenerManagers: { [tableauEventType: string]: SingleEventManager; };\r\n\r\n  public constructor() {\r\n    this._eventListenerManagers = {};\r\n  }\r\n\r\n  public addEventListener(eventType: Contract.TableauEventType,\r\n                          handler: Contract.TableauEventHandlerFn): Contract.TableauEventUnregisterFn {\r\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\r\n      throw TableauException.error(EventListenerManager.UNSUPPORTED_EVENT, [eventType]);\r\n    }\r\n\r\n    return this._eventListenerManagers[eventType].addEventListener(handler);\r\n  }\r\n\r\n  public removeEventListener(eventType: Contract.TableauEventType, handler: Contract.TableauEventHandlerFn): boolean {\r\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\r\n      throw TableauException.error(EventListenerManager.UNSUPPORTED_EVENT, [eventType]);\r\n    }\r\n\r\n    return this._eventListenerManagers[eventType].removeEventListener(handler);\r\n  }\r\n\r\n  protected addNewEventType(eventManager: SingleEventManager): void {\r\n    this._eventListenerManagers[eventManager.eventType] = eventManager;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/EventListenerManager.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport { EnumConverter } from './EnumConverter';\r\nexport { Param } from './Param';\r\nexport { TableauException } from './TableauException';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-utils/src/ApiUtils.ts\n **/","import { TableauException } from './TableauException';\r\n/**\r\n * This class converts from a source enum value to destination enum\r\n * value given a mapping from source to destination when constructed.\r\n */\r\nexport class EnumConverter<TSourceType extends string, TDestinationType> {\r\n  private static MAPPING_NOT_FOUND: string = 'Mapping not found for %1';\r\n  public constructor(\r\n    private _mappings: { [enumVal: string]: TDestinationType; },\r\n    private _defaultVal?: TDestinationType) { }\r\n\r\n  public convert(enumVal: TSourceType, throwIfMissing?: boolean): TDestinationType {\r\n    if (this._mappings.hasOwnProperty(enumVal)) {\r\n      return this._mappings[enumVal as string];\r\n    }\r\n\r\n    if (this._defaultVal !== undefined && !throwIfMissing) {\r\n      return this._defaultVal;\r\n    }\r\n\r\n    throw TableauException.error(EnumConverter.MAPPING_NOT_FOUND, [enumVal]);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-utils/src/EnumConverter.ts\n **/","export class TableauException {\r\n  public static API_NOT_IMPLEMENTED: string = '%1 API not yet implemented.';\r\n  public static UNDEFINED: string = '%1 is undefined.';\r\n  public static INVALID_PARAMETER_VALUE: string = 'Invalid value for parameter: %1. %2';\r\n  public static INVALID_PARAMETER_TYPE: string = 'Invalid type for parameter: %1. %2';\r\n  public static MISSING_PARAMETER: string = 'Missing Parameter: %1.';\r\n  public static UNKNOWN_ERROR: string = 'Unknown error.';\r\n  public static INTERNAL_ERROR: string = 'Internal error: %1.';\r\n  public static INVALID: string = 'Invalid: %1. %2';\r\n  public static IS_NULL: string = '%1 is null.';\r\n\r\n  public static apiNotImplemented (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.API_NOT_IMPLEMENTED, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static isUndefined (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.UNDEFINED, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static isNull (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.IS_NULL, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static invalidParamValue (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.INVALID_PARAMETER_VALUE, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static invalidParamType (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.INVALID_PARAMETER_TYPE, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static missingParameter (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.MISSING_PARAMETER, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static invalid (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.INVALID, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static internalError (params: Array<string>): Error {\r\n    let message: string = TableauException.format(TableauException.INTERNAL_ERROR, params);\r\n    return new Error(message);\r\n  }\r\n\r\n  public static error (message: string, params?: Array<string>): Error {\r\n    let result: string;\r\n    if (params) {\r\n      result = TableauException.format(message, params);\r\n    } else {\r\n      result = message;\r\n    }\r\n    return new Error(result);\r\n  }\r\n\r\n  public static format (message: string, params: Array<string>): string {\r\n    for (let i = 0; i < params.length; i++) {\r\n      let match: string = '%' + (i + 1);\r\n      message = message.replace(new RegExp(match, 'g'), params[i]);\r\n    }\r\n    message = message.replace(new RegExp('%[0-9]+', 'g'), '');\r\n    message = message.trim();\r\n    return message;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-utils/src/TableauException.ts\n **/","import { TableauException } from './TableauException';\r\nexport class Param {\r\n  /**\r\n   * Verifies that an incoming parameter is 'truthy' and throws\r\n   * an error if it's not. This will throw an error if the value\r\n   * is null, undefined, NaN, the empty string, 0, or false.\r\n   *\r\n   * @param argumentValue value to verify\r\n   * @param argumentName name of argument to verify\r\n   */\r\n  /*tslint:disable-next-line */\r\n  public static verifyValue(argumentValue: any, argumentName: string): void {\r\n    if (!argumentValue) {\r\n      throw TableauException.invalidParamValue([argumentName]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Verifies that a string is valid.  Throws an error if the string is\r\n   * null, undefined, or NaN.\r\n   *\r\n   * @param argumentValue value to verify\r\n   * @param argumentName name of argument to verify\r\n   */\r\n  public static verifyString(argumentValue: string, argumentName: string): void {\r\n    if (argumentValue === null || argumentValue === undefined) {\r\n      throw TableauException.invalidParamValue([argumentName]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Verifies the value is part of the Enum\r\n   *\r\n   * String enums are {string : string} dictionaries which are not reverse mappable\r\n   * This is an ugly workaround\r\n   * @param value value to verify\r\n   * @param enumType enum to verify against\r\n   */\r\n  /* tslint:disable:no-any */\r\n  public static isValidEnumValue<EnumType>(value: EnumType, enumType: any): boolean {\r\n    let isValid: boolean = false;\r\n    Object.keys(enumType).forEach((enumKey) => {\r\n      if (enumType[enumKey] === value.toString()) {\r\n        isValid = true;\r\n      }\r\n    });\r\n    return isValid;\r\n  }\r\n  /* tslint:enable:no-any */\r\n\r\n  /**\r\n   * serializes the date into the format that the server expects.\r\n   * @param date the date to serialize\r\n   */\r\n  public static serializeDateForPlatform(date: Date): string {\r\n    const year: number = date.getUTCFullYear();\r\n    const month: number = date.getUTCMonth() + 1;\r\n    const day: number = date.getUTCDate();\r\n    const hh: number = date.getUTCHours();\r\n    const mm: number = date.getUTCMinutes();\r\n    const sec: number = date.getUTCSeconds();\r\n    return year + '-' + month + '-' + day + ' ' + hh + ':' + mm + ':' + sec;\r\n  }\r\n\r\n  public static serializeBooleanForPlatform(bool: boolean): string {\r\n    return bool ? 'true' : 'false';\r\n  }\r\n\r\n  public static serializeNumberForPlatform(num: number): string {\r\n    return num.toString(10);\r\n  }\r\n\r\n  /**\r\n   * Verifies the params min and max for applying range filter\r\n   * @param min range min\r\n   * @param max range max\r\n   */\r\n  /* tslint:disable:no-any */\r\n  public static verifyRangeParamType(min: any, max: any): void {\r\n  /* tslint:enable:no-any */\r\n    if (!min && !max) {\r\n      throw TableauException.invalidParamValue(['Range parameters', 'At least one of min or max is required.']);\r\n    }\r\n\r\n    if (!Param.isTypeNumber(min) && !Param.isTypeDate(min)) {\r\n      throw TableauException.invalidParamType(['Range parameters', 'Only Date and number are allowed for parameter min.']);\r\n    }\r\n\r\n    if (!Param.isTypeNumber(max) && !Param.isTypeDate(max)) {\r\n      throw TableauException.invalidParamType(['Range parameters', 'Only Date and number are allowed for parameter max.']);\r\n    }\r\n\r\n    if (typeof(min) !== typeof(max)) {\r\n      throw TableauException.invalidParamType(['Range parameters', 'Parameters min and max should be of the same type.']);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Verifies the input is a number\r\n   */\r\n  /* tslint:disable:no-any */\r\n  public static isTypeNumber(input: any): boolean {\r\n    return typeof(input) === 'number' || input instanceof Number;\r\n  }\r\n  /* tslint:enable:no-any */\r\n\r\n  /**\r\n   * Verifies the input is a Date\r\n   */\r\n  /* tslint:disable:no-any */\r\n  public static isTypeDate(input: any): boolean {\r\n    return input instanceof Date;\r\n  }\r\n  /* tslint:enable:no-any */\r\n\r\n  /* tslint:disable-next-line:no-any */\r\n  public static isTypeString(input: any): boolean {\r\n    return typeof(input) === 'string' || input instanceof String;\r\n  }\r\n\r\n  /* tslint:disable-next-line:no-any */\r\n  public static isTypeBool(input: any): boolean {\r\n    return typeof(input) === 'boolean' || input instanceof Boolean;\r\n  }\r\n\r\n  /* tslint:disable-next-line:no-any */\r\n  public static serializeParamterValue(value: any): string {\r\n    if (Param.isTypeNumber(value)) {\r\n      return Param.serializeNumberForPlatform(value as number);\r\n    } else if (Param.isTypeDate(value)) {\r\n      return Param.serializeDateForPlatform(value as Date);\r\n    } else if (Param.isTypeBool(value)) {\r\n      return Param.serializeBooleanForPlatform(value as boolean);\r\n    } else if (Param.isTypeString(value)) {\r\n      return value;\r\n    } else {\r\n      throw TableauException.invalidParamValue(['value']);\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-utils/src/Param.ts\n **/","import { VersionNumber as VersionNumberContract } from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\n/**\r\n * Represents the current version of the extensions library\r\n */\r\nexport class VersionNumber implements VersionNumberContract {\r\n\r\n  // Using some webpack tricks, we can inject this version into our code (kinda like c++ preprocessor stuff)\r\n  private static _instance: VersionNumber;\r\n  private static INVALID_VERSION_NUMBER: string = 'Invalid version number: ';\r\n\r\n  /**\r\n   * Gets the singleton instance of the version number.\r\n   */\r\n  public static get Instance(): VersionNumber {\r\n    return VersionNumber._instance;\r\n  }\r\n\r\n  public static SetVersionNumber(numString: string): void {\r\n    VersionNumber._instance = new VersionNumber(numString);\r\n  }\r\n\r\n  public readonly major: number;\r\n  public readonly minor: number;\r\n  public readonly fix: number;\r\n\r\n  // private constructor so everyone uses the singleton instance\r\n  private constructor(versionString: string) {\r\n    const parts = versionString.split('.').map(p => parseInt(p, 10));\r\n    if (parts.length !== 3) {\r\n      throw TableauException.error(VersionNumber.INVALID_VERSION_NUMBER, [versionString]);\r\n    }\r\n\r\n    this.major = parts[0];\r\n    this.minor = parts[1];\r\n    this.fix = parts[2];\r\n  }\r\n\r\n  public get formattedValue(): string {\r\n    return `${this.major}.${this.minor}.${this.fix}`;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/VersionNumber.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { DashboardObjectType, ExtensionDashboardInfo, SheetPath, VisualId } from '@tableau/api-internal-contract';\r\n\r\nimport { DashboardObject } from '../DashboardObject';\r\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\r\nimport { Point } from '../Point';\r\nimport { Size } from '../Size';\r\nimport { Worksheet } from '../Worksheet';\r\n\r\nimport { SheetImpl } from './SheetImpl';\r\nimport { SheetInfoImpl } from './SheetInfoImpl';\r\nimport { WorksheetImpl } from './WorksheetImpl';\r\n\r\nexport class DashboardImpl extends SheetImpl {\r\n  private _worksheets: Array<Contract.Worksheet>;\r\n  private _objects: Array<Contract.DashboardObject>;\r\n\r\n  public constructor(private _info: ExtensionDashboardInfo, private _sheetPath: SheetPath) {\r\n    super(new SheetInfoImpl(_info.name, Contract.SheetType.Dashboard, new Size(_info.size.h, _info.size.w)));\r\n  }\r\n\r\n  public get worksheets(): Array<Contract.Worksheet> {\r\n    return this._worksheets;\r\n  }\r\n\r\n  public get objects(): Array<Contract.DashboardObject> {\r\n    return this._objects;\r\n  }\r\n\r\n  public initializeWithPublicInterfaces(dashboard: Contract.Dashboard): void {\r\n    this._worksheets = new Array<Worksheet>();\r\n    this._objects = new Array<Contract.DashboardObject>();\r\n\r\n    // Process all the zones which are contained in this dashboard\r\n    for (const zone of this._info.zones) {\r\n      let worksheet: Worksheet | undefined = undefined;\r\n\r\n      const zoneSize = new Size(zone.height, zone.width);\r\n\r\n      if (zone.zoneType === DashboardObjectType.Worksheet) {\r\n        const sheetInfo = new SheetInfoImpl(zone.name, Contract.SheetType.Worksheet, zoneSize);\r\n        const vizId: VisualId = {\r\n          worksheet: zone.name,\r\n          dashboard: this._info.name,\r\n          storyboard: this._sheetPath.storyboard,\r\n          flipboardZoneID: this._sheetPath.flipboardZoneID,\r\n          storyPointID: this._sheetPath.storyPointID\r\n        };\r\n\r\n        const worksheetImpl = new WorksheetImpl(sheetInfo, vizId, dashboard);\r\n        worksheet = new Worksheet(worksheetImpl);\r\n        this._worksheets.push(worksheet);\r\n      }\r\n\r\n      const zonePoint = new Point(zone.x, zone.y);\r\n\r\n      const dashboardObject = new DashboardObject(\r\n        dashboard,\r\n        InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType),\r\n        zonePoint,\r\n        zoneSize,\r\n        worksheet\r\n      );\r\n\r\n      this._objects.push(dashboardObject);\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/DashboardImpl.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport * from './AnalyticsInterfaces';\r\nexport * from './DataSourceInterfaces';\r\nexport * from './DataTableInterfaces';\r\nexport * from './EncodingInterfaces';\r\nexport * from './Enums';\r\nexport * from './EventInterfaces';\r\nexport * from './FilterInterfaces';\r\nexport * from './SelectionInterfaces';\r\nexport * from './ParameterInterfaces';\r\nexport * from './SelectionInterfaces';\r\nexport * from './SheetInterfaces';\r\n\r\nexport { Extensions } from './Namespaces/Extensions';\r\nexport { DashboardContent } from './Namespaces/DashboardContent';\r\nexport { Environment } from './Namespaces/Environment';\r\nexport { Settings } from './Namespaces/Settings';\r\nexport { UI } from './Namespaces/UI';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-external-contract/src/ApiExternalContract.ts\n **/","// All enum values made available to Extensions developers.\r\n// Enums should be kept in alphabetical order.\r\n\r\n/**\r\n * The context in which the Extensions is currently running.\r\n */\r\nexport enum ExtensionContext {\r\n  Desktop = 'desktop',\r\n  Server = 'server'\r\n}\r\n\r\n/**\r\n * The mode in which the Extensions is currently running.\r\n */\r\nexport enum ExtensionMode {\r\n  Authoring = 'authoring',\r\n  Viewing = 'viewing'\r\n}\r\n\r\nexport enum AnalyticsObjectType {\r\n  Cluster = 'cluster',\r\n  Forecast = 'forecast',\r\n  TrendLine = 'trend-line'\r\n}\r\n\r\nexport enum ColumnType {\r\n  Discrete = 'discrete',\r\n  Continuous = 'continuous'\r\n}\r\n\r\n/**\r\n * What the object represents in a dashboard.\r\n */\r\nexport enum DashboardObjectType {\r\n  Blank = 'blank',\r\n  Worksheet = 'worksheet',\r\n  QuickFilter = 'quick-filter',\r\n  ParameterControl = 'parameter-control',\r\n  PageFilter = 'page-filter',\r\n  Legend = 'legend',\r\n  Title = 'title',\r\n  Text = 'text',\r\n  Image = 'image',\r\n  WebPage = 'web-page',\r\n  Extension = 'extension'\r\n}\r\n\r\n/**\r\n * The different types of data a value can have\r\n */\r\nexport enum DataType {\r\n  String = 'string',\r\n  Int = 'int',\r\n  Float = 'float',\r\n  Bool = 'bool',\r\n  Date = 'date',\r\n  DateTime = 'date-time',\r\n  Spatial = 'spatial'\r\n}\r\n\r\n/**\r\n * Valid date ranges for a relative date filter.\r\n */\r\nexport enum DateRangeType {\r\n  Last = 'last',\r\n  LastN = 'last-n',\r\n  Next = 'next',\r\n  NextN = 'next-n',\r\n  Current = 'current',\r\n  ToDate = 'to-date'\r\n}\r\n\r\n/**\r\n * Types of dialog event for event listening between a parent Extensions and a popup dialog.\r\n */\r\nexport enum DialogEventType {\r\n  DialogMessage = 'dialog-message',\r\n  DialogEvent = 'dialog-event'\r\n}\r\n\r\nexport enum EncodingType {\r\n  Column = 'column',\r\n  Row = 'row',\r\n  Page = 'page',\r\n  Filter = 'filter',\r\n  MarksType = 'marks-type',\r\n  MeasureValues = 'measure-values',\r\n  Color = 'color',\r\n  Size = 'size',\r\n  Label = 'label',\r\n  Detail = 'detail',\r\n  Tooltip = 'tooltip',\r\n  Shape = 'shape',\r\n  Path = 'path',\r\n  Angle = 'angle'\r\n}\r\n\r\n/**\r\n * All error codes used by the Extensions API.\r\n */\r\nexport enum ErrorCodes {\r\n  /**\r\n   * Only one dialog can be opened at time with the UI namespace functionality.\r\n   */\r\n  DialogAlreadyOpen = 'dialog-already-open',\r\n  /**\r\n   * The open dialog was closed by the user.\r\n   */\r\n  DialogClosedByUser = 'dialog-closed-by-user',\r\n  /**\r\n   * An error occurred while attempting to perform a filter operation.\r\n   */\r\n  FilterCannotBePerformed = 'filter-cannot-be-performed',\r\n  /**\r\n   * An error occurred within the Tableau Extensions API. Contact Tableau Support.\r\n   */\r\n  InternalError = 'internal-error',\r\n  /**\r\n   * An invalid aggregation was specified for the filter, such as setting a range filter to \"SUM(Sales)\" instead of \"Sales\".\r\n   */\r\n  InvalidAggregationFieldName = 'invalid-aggregation-field-name',\r\n  /**\r\n   * A dialog must first launch to, and send messages from, the same domain as the parent Extensions.\r\n   */\r\n  InvalidDomainDialog = 'invalid-dialog-domain',\r\n  /**\r\n   * An invalid date was specified in a method that required a date parameter.\r\n   */\r\n  InvalidDateParameter = 'invalid-date-parameter',\r\n  /**\r\n   * A filter operation was attempted on a field that does not exist in the data source.\r\n   */\r\n  InvalidFilterFieldName = 'invalid-filter-field-name',\r\n  /**\r\n   * A filter operation was attempted using a value that is the wrong data type or format.\r\n   */\r\n  InvalidFilterFieldValue = 'invalid-filter-field-value',\r\n  /**\r\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\r\n   */\r\n  InvalidParameter = 'invalid-parameter',\r\n  /**\r\n   * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.\r\n   */\r\n  InvalidSelectionDate = 'invalid-selection-date',\r\n  /**\r\n   * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.\r\n   */\r\n  InvalidSelectionFieldName = 'invalid-selection-field-name',\r\n  /**\r\n   * An invalid value was specified in a Sheet.selectMarksAsync() call.\r\n   */\r\n  InvalidSelectionValue = 'invalid-selection-value',\r\n  /**\r\n   * A required parameter was not specified, null, or an empty string/array.\r\n   */\r\n  NullOrEmptyParameter = 'null-or-empty-parameter',\r\n  /**\r\n   * An unknown event name was specified in the call to Viz.addEventListeneror Viz.removeEventListener.\r\n   */\r\n  UnsupportedEventName = 'unsupported-event-name',\r\n  /**\r\n   * A method was used for a type of datasource that doesn't support that method (see getActiveTablesAsync for an example)\r\n   */\r\n  UnsupportedMethodForDataSourceType = 'unsupported-method-for-data-source-type'\r\n}\r\n\r\n/**\r\n *  Type of aggregation on a field.\r\n */\r\nexport enum FieldAggregationType {\r\n  Sum = 'sum',\r\n  Avg = 'avg',\r\n  Min = 'min',\r\n  Max = 'max',\r\n  Stdev = 'stdev',\r\n  Stdevp = 'stdevp',\r\n  Var = 'var',\r\n  Varp = 'varp',\r\n  Count = 'count',\r\n  Countd = 'countd',\r\n  Median = 'median',\r\n  Attr = 'attr',\r\n  None = 'none',\r\n  Year = 'year',\r\n  Qtr = 'qtr',\r\n  Month = 'month',\r\n  Day = 'day',\r\n  Hour = 'hour',\r\n  Minute = 'minute',\r\n  Second = 'second',\r\n  Week = 'week',\r\n  Weekday = 'weekday',\r\n  MonthYear = 'month-year',\r\n  Mdy = 'mdy',\r\n  End = 'end',\r\n  TruncYear = 'trunc-year',\r\n  TruncQtr = 'trunc-qtr',\r\n  TruncMonth = 'trunc-month',\r\n  TruncWeek = 'trunc-week',\r\n  TruncDay = 'trunc-day',\r\n  TruncHour = 'trunc-hour',\r\n  TruncMinute = 'trunc-minute',\r\n  TruncSecond = 'trunc-second',\r\n  Quart1 = 'quart1',\r\n  Quart3 = 'quart3',\r\n  Skewness = 'skewness',\r\n  Kurtosis = 'kurtosis',\r\n  InOut = 'in-out',\r\n  User = 'user'\r\n}\r\n\r\n/**\r\n * Role of a field.\r\n */\r\nexport enum FieldRoleType {\r\n  Dimension = 'dimension',\r\n  Measure = 'measure',\r\n  Unknown = 'unknown'\r\n}\r\n\r\n/**\r\n * An enumeration of the valid types of filters that can be applied.\r\n */\r\nexport enum FilterType {\r\n  Categorical = 'categorical',\r\n  Range = 'range',\r\n  Hierarchical = 'hierarchical',\r\n  RelativeDate = 'relative-date'\r\n}\r\n\r\n/**\r\n * The different update types for applying filter\r\n */\r\nexport enum FilterUpdateType {\r\n  Add = 'add',\r\n  All = 'all',\r\n  Replace = 'replace',\r\n  Remove = 'remove'\r\n}\r\n\r\n/**\r\n * The domain type for a filter\r\n */\r\nexport enum FilterDomainType {\r\n  /**\r\n   * The domain values that are relevant to the specified filter\r\n   * i.e. the domain is restricted by a previous filter\r\n   */\r\n  Relevant = 'relevant',\r\n  /**\r\n   * list of all possible domain values from database\r\n   */\r\n  Database = 'database'\r\n}\r\n\r\n/**\r\n * The option for specifying which values to include for filtering\r\n * Indicates what to do with null values for a given filter or mark selection call.\r\n */\r\nexport enum FilterNullOption {\r\n  NullValues = 'null-values',\r\n  NonNullValues = 'non-null-values',\r\n  AllValues = 'all-values'\r\n}\r\n\r\n/**\r\n * Type of mark for a given marks card in a viz.\r\n */\r\nexport enum MarkType {\r\n  Bar = 'bar',\r\n  Line = 'line',\r\n  Area = 'area',\r\n  Square = 'square',\r\n  Circle = 'circle',\r\n  Shape = 'shape',\r\n  Text = 'text',\r\n  Map = 'map',\r\n  Pie = 'pie',\r\n  GanttBar = 'gantt-bar',\r\n  Polygon = 'polygon'\r\n}\r\n\r\n/**\r\n * An enumeration describing the different types of allowable values.\r\n * This is used for restricting the domain of a parameter\r\n */\r\nexport enum ParameterValueType {\r\n  All = 'all',\r\n  List = 'list',\r\n  Range = 'range'\r\n}\r\n\r\n/**\r\n * Date period used in filters and in parameters.\r\n */\r\nexport enum PeriodType {\r\n  Years = 'years',\r\n  Quarters = 'quarters',\r\n  Months = 'months',\r\n  Weeks = 'weeks',\r\n  Days = 'days',\r\n  Hours = 'hours',\r\n  Minutes = 'minutes',\r\n  Seconds = 'seconds'\r\n}\r\n\r\nexport enum QuickTableCalcType {\r\n  RunningTotal = 'running-total',\r\n  Difference = 'difference',\r\n  PercentDifference = 'percent-difference',\r\n  PercentOfTotal = 'percent-of-total',\r\n  Rank = 'rank',\r\n  Percentile = 'percentile',\r\n  MovingAverage = 'moving-average',\r\n  YTDTotal = 'ytd-total',\r\n  CompoundGrowthRate = 'compound-growth-rate',\r\n  YearOverYearGrowth = 'year-over-year-growth',\r\n  YTDGrowth = 'ytd-growth',\r\n  Undefined = 'undefined'\r\n}\r\n\r\n/**\r\n * Enum for specifying the selection type for select marks api.\r\n */\r\nexport enum SelectionUpdateType {\r\n  Replace = 'select-replace',\r\n  Add = 'select-add',\r\n  Remove = 'select-remove'\r\n}\r\n\r\n/**\r\n * The type of sheet a Sheet object represents\r\n */\r\nexport enum SheetType {\r\n  Dashboard = 'dashboard',\r\n  Story = 'story',\r\n  Worksheet = 'worksheet'\r\n}\r\n\r\nexport enum SortDirection {\r\n  Increasing = 'increasing',\r\n  Decreasing = 'decreasing'\r\n}\r\n\r\n/**\r\n * Represents a certain type of event which can be listened for\r\n */\r\nexport enum TableauEventType {\r\n  /** Raised when any filter has changed state.*/\r\n  FilterChanged = 'filter-changed',\r\n\r\n  /** The selected marks on a visualization has changed */\r\n  MarkSelectionChanged = 'mark-selection-changed',\r\n\r\n  /** A parameter has had its value modified */\r\n  ParameterChanged = 'parameter-changed'\r\n}\r\n\r\nexport enum TrendLineModelType {\r\n  Linear = 'linear',\r\n  Logarithmic = 'logarithmic',\r\n  Exponential = 'exponential',\r\n  Polynomial = 'polynomial'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-external-contract/src/Enums.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\n/**\r\n * Implementation of the dashboard objects - the zones in a dashboard.\r\n * This does not follow the Impl pattern as it is just a property bag.\r\n */\r\nexport class DashboardObject implements Contract.DashboardObject {\r\n  public constructor(\r\n    private _dashboard: Contract.Dashboard,\r\n    private _type: Contract.DashboardObjectType,\r\n    private _position: Contract.Point,\r\n    private _size: Contract.Size,\r\n    private _worksheet: Contract.Worksheet | undefined\r\n  ) { }\r\n\r\n  public get dashboard(): Contract.Dashboard {\r\n    return this._dashboard;\r\n  }\r\n\r\n  public get type(): Contract.DashboardObjectType {\r\n    return this._type;\r\n  }\r\n\r\n  public get position(): Contract.Point {\r\n    return this._position;\r\n  }\r\n\r\n  public get size(): Contract.Size {\r\n    return this._size;\r\n  }\r\n\r\n  public get worksheet(): Contract.Worksheet | undefined {\r\n    return this._worksheet;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/DashboardObject.ts\n **/","import {\r\n  ColumnType as ExternalColumnType,\r\n  DashboardObjectType as ExternalDashboardObjectType,\r\n  DataType as ExternalDataType,\r\n  DateRangeType as ExternalDateRangeType,\r\n  ExtensionContext as ExternalExtensionsContext,\r\n  ExtensionMode as ExternalExtensionsMode,\r\n  FieldAggregationType as ExternalFieldAggregationType,\r\n  FieldRoleType as ExternalFieldRoleType,\r\n  FilterType as ExternalFilterType,\r\n  FilterUpdateType as ExternalFilterUpdateType,\r\n  ParameterValueType as ExternalParameterValueType,\r\n  PeriodType as ExternalDatePeriod,\r\n  SheetType as ExternalSheetType,\r\n} from '@tableau/api-external-contract';\r\n\r\nimport {\r\n  ColumnType as InternalColumnType,\r\n  DashboardObjectType as InternalDashboardObjectType,\r\n  DataType as InternalDataType,\r\n  DateRangeType as InternalDateRangeType,\r\n  DateStepPeriod as InternalDateStepPeriod,\r\n  DomainRestrictionType as InternalDomainRestrictionType,\r\n  ExtensionContext as InternalExtensionsContext,\r\n  ExtensionMode as InternalExtensionsMode,\r\n  FieldAggregationType as InternalFieldAggregationType,\r\n  FieldRoleType as InternalFieldRoleType,\r\n  FilterType as InternalFilterType,\r\n  FilterUpdateType as InternalFilterUpdateType,\r\n  SheetType as InternalSheetType,\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport { EnumConverter } from '@tableau/api-utils';\r\n\r\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\r\n/**\r\n * Maps enums used by the internal-api-contract to the enums used\r\n * in the external-api-contract, which developers code against.\r\n */\r\nexport class InternalToExternalEnumMappings {\r\n  public static extensionContext = new EnumConverter<InternalExtensionsContext, ExternalExtensionsContext>({\r\n    [InternalExtensionsContext.Desktop]: ExternalExtensionsContext.Desktop,\r\n    [InternalExtensionsContext.Server]: ExternalExtensionsContext.Server\r\n  });\r\n\r\n  public static extensionMode = new EnumConverter<InternalExtensionsMode, ExternalExtensionsMode>({\r\n    [InternalExtensionsMode.Authoring]: ExternalExtensionsMode.Authoring,\r\n    [InternalExtensionsMode.Viewing]: ExternalExtensionsMode.Viewing\r\n  });\r\n\r\n  public static columnType = new EnumConverter<InternalColumnType, ExternalColumnType>({\r\n    [InternalColumnType.Continuous]: ExternalColumnType.Continuous,\r\n    [InternalColumnType.Discrete]: ExternalColumnType.Discrete\r\n  });\r\n\r\n  public static fieldAggregationType = new EnumConverter<InternalFieldAggregationType, ExternalFieldAggregationType>({\r\n    [InternalFieldAggregationType.Attr]: ExternalFieldAggregationType.Attr,\r\n    [InternalFieldAggregationType.Avg]: ExternalFieldAggregationType.Avg,\r\n    [InternalFieldAggregationType.Count]: ExternalFieldAggregationType.Count,\r\n    [InternalFieldAggregationType.Countd]: ExternalFieldAggregationType.Countd,\r\n    [InternalFieldAggregationType.Day]: ExternalFieldAggregationType.Day,\r\n    [InternalFieldAggregationType.End]: ExternalFieldAggregationType.End,\r\n    [InternalFieldAggregationType.Hour]: ExternalFieldAggregationType.Hour,\r\n    [InternalFieldAggregationType.InOut]: ExternalFieldAggregationType.InOut,\r\n    [InternalFieldAggregationType.Kurtosis]: ExternalFieldAggregationType.Kurtosis,\r\n    [InternalFieldAggregationType.Max]: ExternalFieldAggregationType.Max,\r\n    [InternalFieldAggregationType.Mdy]: ExternalFieldAggregationType.Mdy,\r\n    [InternalFieldAggregationType.Median]: ExternalFieldAggregationType.Median,\r\n    [InternalFieldAggregationType.Min]: ExternalFieldAggregationType.Min,\r\n    [InternalFieldAggregationType.Minute]: ExternalFieldAggregationType.Minute,\r\n    [InternalFieldAggregationType.MonthYear]: ExternalFieldAggregationType.MonthYear,\r\n    [InternalFieldAggregationType.None]: ExternalFieldAggregationType.None,\r\n    [InternalFieldAggregationType.Qtr]: ExternalFieldAggregationType.Qtr,\r\n    [InternalFieldAggregationType.Quart1]: ExternalFieldAggregationType.Quart1,\r\n    [InternalFieldAggregationType.Quart3]: ExternalFieldAggregationType.Quart3,\r\n    [InternalFieldAggregationType.Second]: ExternalFieldAggregationType.Second,\r\n    [InternalFieldAggregationType.Skewness]: ExternalFieldAggregationType.Skewness,\r\n    [InternalFieldAggregationType.Stdev]: ExternalFieldAggregationType.Stdev,\r\n    [InternalFieldAggregationType.Stdevp]: ExternalFieldAggregationType.Stdevp,\r\n    [InternalFieldAggregationType.Sum]: ExternalFieldAggregationType.Sum,\r\n    [InternalFieldAggregationType.TruncDay]: ExternalFieldAggregationType.TruncDay,\r\n    [InternalFieldAggregationType.TruncHour]: ExternalFieldAggregationType.TruncHour,\r\n    [InternalFieldAggregationType.TruncMinute]: ExternalFieldAggregationType.TruncMinute,\r\n    [InternalFieldAggregationType.TruncMonth]: ExternalFieldAggregationType.TruncMonth,\r\n    [InternalFieldAggregationType.TruncQtr]: ExternalFieldAggregationType.TruncQtr,\r\n    [InternalFieldAggregationType.TruncSecond]: ExternalFieldAggregationType.TruncSecond,\r\n    [InternalFieldAggregationType.TruncWeek]: ExternalFieldAggregationType.TruncWeek,\r\n    [InternalFieldAggregationType.TruncYear]: ExternalFieldAggregationType.TruncYear,\r\n    [InternalFieldAggregationType.User]: ExternalFieldAggregationType.User,\r\n    [InternalFieldAggregationType.Var]: ExternalFieldAggregationType.Var,\r\n    [InternalFieldAggregationType.Varp]: ExternalFieldAggregationType.Varp,\r\n    [InternalFieldAggregationType.Week]: ExternalFieldAggregationType.Week,\r\n    [InternalFieldAggregationType.Weekday]: ExternalFieldAggregationType.Weekday,\r\n    [InternalFieldAggregationType.Year]: ExternalFieldAggregationType.Year,\r\n  });\r\n\r\n  public static fieldRoleType = new EnumConverter<InternalFieldRoleType, ExternalFieldRoleType>({\r\n    [InternalFieldRoleType.Dimension]: ExternalFieldRoleType.Dimension,\r\n    [InternalFieldRoleType.Measure]: ExternalFieldRoleType.Measure,\r\n    [InternalFieldRoleType.Unknown]: ExternalFieldRoleType.Unknown,\r\n  });\r\n\r\n  public static sheetType = new EnumConverter<InternalSheetType, ExternalSheetType>({\r\n    [InternalSheetType.Dashboard]: ExternalSheetType.Dashboard,\r\n    [InternalSheetType.Story]: ExternalSheetType.Story,\r\n    [InternalSheetType.Worksheet]: ExternalSheetType.Worksheet\r\n  });\r\n\r\n  public static dashboardObjectType = new EnumConverter<InternalDashboardObjectType, ExternalDashboardObjectType>({\r\n    [InternalDashboardObjectType.Extension]: ExternalDashboardObjectType.Extension,\r\n    [InternalDashboardObjectType.Blank]: ExternalDashboardObjectType.Blank,\r\n    [InternalDashboardObjectType.Image]: ExternalDashboardObjectType.Image,\r\n    [InternalDashboardObjectType.Legend]: ExternalDashboardObjectType.Legend,\r\n    [InternalDashboardObjectType.PageFilter]: ExternalDashboardObjectType.PageFilter,\r\n    [InternalDashboardObjectType.ParameterControl]: ExternalDashboardObjectType.ParameterControl,\r\n    [InternalDashboardObjectType.QuickFilter]: ExternalDashboardObjectType.QuickFilter,\r\n    [InternalDashboardObjectType.Text]: ExternalDashboardObjectType.Text,\r\n    [InternalDashboardObjectType.Title]: ExternalDashboardObjectType.Title,\r\n    [InternalDashboardObjectType.WebPage]: ExternalDashboardObjectType.WebPage,\r\n    [InternalDashboardObjectType.Worksheet]: ExternalDashboardObjectType.Worksheet\r\n  });\r\n\r\n  public static dataType = new EnumConverter<InternalDataType, ExternalDataType>({\r\n    [InternalDataType.Bool]: ExternalDataType.Bool,\r\n    [InternalDataType.Date]: ExternalDataType.Date,\r\n    [InternalDataType.DateTime]: ExternalDataType.DateTime,\r\n    [InternalDataType.Float]: ExternalDataType.Float,\r\n    [InternalDataType.Int]: ExternalDataType.Int,\r\n    [InternalDataType.String]: ExternalDataType.String\r\n  });\r\n\r\n  public static filterUpdateType = new EnumConverter<InternalFilterUpdateType, ExternalFilterUpdateType>({\r\n    [InternalFilterUpdateType.Add]: ExternalFilterUpdateType.Add,\r\n    [InternalFilterUpdateType.All]: ExternalFilterUpdateType.All,\r\n    [InternalFilterUpdateType.Remove]: ExternalFilterUpdateType.Remove,\r\n    [InternalFilterUpdateType.Replace]: ExternalFilterUpdateType.Replace\r\n  });\r\n\r\n  public static allowableValues = new EnumConverter<InternalDomainRestrictionType, ExternalParameterValueType>({\r\n    [InternalDomainRestrictionType.All]: ExternalParameterValueType.All,\r\n    [InternalDomainRestrictionType.List]: ExternalParameterValueType.List,\r\n    [InternalDomainRestrictionType.Range]: ExternalParameterValueType.Range\r\n  });\r\n\r\n  public static dateStepPeriod = new EnumConverter<InternalDateStepPeriod, ExternalDatePeriod>({\r\n    [InternalDateStepPeriod.Years]: ExternalDatePeriod.Years,\r\n    [InternalDateStepPeriod.Quarters]: ExternalDatePeriod.Quarters,\r\n    [InternalDateStepPeriod.Months]: ExternalDatePeriod.Months,\r\n    [InternalDateStepPeriod.Weeks]: ExternalDatePeriod.Weeks,\r\n    [InternalDateStepPeriod.Days]: ExternalDatePeriod.Days,\r\n    [InternalDateStepPeriod.Hours]: ExternalDatePeriod.Hours,\r\n    [InternalDateStepPeriod.Minutes]: ExternalDatePeriod.Minutes,\r\n    [InternalDateStepPeriod.Seconds]: ExternalDatePeriod.Seconds\r\n  });\r\n\r\n  public static dateRangeType = new EnumConverter<InternalDateRangeType, ExternalDateRangeType>({\r\n    [InternalDateRangeType.Current]: ExternalDateRangeType.Current,\r\n    [InternalDateRangeType.Last]: ExternalDateRangeType.Last,\r\n    [InternalDateRangeType.LastN]: ExternalDateRangeType.LastN,\r\n    [InternalDateRangeType.Next]: ExternalDateRangeType.Next,\r\n    [InternalDateRangeType.NextN]: ExternalDateRangeType.NextN,\r\n    [InternalDateRangeType.ToDate]: ExternalDateRangeType.ToDate\r\n  });\r\n\r\n  public static filterType = new EnumConverter<InternalFilterType, ExternalFilterType>({\r\n    [InternalFilterType.Categorical]: ExternalFilterType.Categorical,\r\n    [InternalFilterType.Range] : ExternalFilterType.Range,\r\n    [InternalFilterType.RelativeDate]: ExternalFilterType.RelativeDate,\r\n    [InternalFilterType.Hierarchical]: ExternalFilterType.Hierarchical\r\n  });\r\n}\r\n/* tslint:enable:typedef */\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/EnumMappings/InternalToExternalEnumMappings.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nexport class Point implements Contract.Point {\r\n  public constructor(private _x: number, private _y: number) { }\r\n\r\n  public get x(): number {\r\n    return this._x;\r\n  }\r\n\r\n  public get y(): number {\r\n    return this._y;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Point.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nexport class Size implements Contract.Size {\r\n  public constructor(private _height: number, private _width: number) { }\r\n\r\n  public get height(): number {\r\n    return this._height;\r\n  }\r\n\r\n  public get width(): number {\r\n    return this._width;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Size.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { Sheet } from './Sheet';\r\n\r\nimport { WorksheetImpl } from './Impl/WorksheetImpl';\r\n\r\nexport class Worksheet extends Sheet implements Contract.Worksheet {\r\n  public constructor(private _worksheetImpl: WorksheetImpl) {\r\n    super(_worksheetImpl);\r\n\r\n    // Call to initialize events and then call down to the event listener manager to handle things\r\n    this._worksheetImpl.initializeEvents(this).forEach(e => this.addNewEventType(e));\r\n  }\r\n\r\n  public get parentDashboard(): Contract.Dashboard {\r\n    return this._worksheetImpl.parentDashboard;\r\n  }\r\n\r\n  public applyFilterAsync(\r\n    fieldName: string, values: Array<string>, updateType: Contract.FilterUpdateType, options: Contract.FilterOptions): Promise<string> {\r\n      return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options);\r\n  }\r\n\r\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\r\n    return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions);\r\n  }\r\n\r\n  public clearFilterAsync(fieldName: string): Promise<string> {\r\n    return this._worksheetImpl.clearFilterAsync(fieldName);\r\n  }\r\n\r\n  public getAnalyticObjectsAsync(): Promise<Array<Contract.AnalyticsObject>> {\r\n    throw TableauException.apiNotImplemented(['getAnalyticObjectsAsync']);\r\n  }\r\n\r\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\r\n    return this._worksheetImpl.getDataSourcesAsync();\r\n  }\r\n\r\n  public getEncodingsAsync(): Promise<Array<Contract.Encoding>> {\r\n    throw TableauException.apiNotImplemented(['getEncodingsAsync']);\r\n  }\r\n\r\n  public getFiltersAsync(): Promise<Contract.Filter[]> {\r\n    return this._worksheetImpl.getFiltersAsync();\r\n  }\r\n\r\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\r\n    return this._worksheetImpl.getSelectedMarksAsync();\r\n  }\r\n\r\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\r\n    return this._worksheetImpl.getHighlightedMarksAsync();\r\n  }\r\n\r\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\r\n    return this._worksheetImpl.getSummaryDataAsync(options);\r\n  }\r\n\r\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\r\n    return this._worksheetImpl.getUnderlyingDataAsync(options);\r\n  }\r\n\r\n  public clearSelectedMarksAsync(): Promise<void> {\r\n    return this._worksheetImpl.clearSelectedMarksAsync();\r\n  }\r\n\r\n  public selectMarksByIDAsync(marksInfo: Array<Contract.MarkInfo>, updateType: Contract.SelectionUpdateType): Promise<void> {\r\n    return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType);\r\n  }\r\n\r\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>,\r\n                                 selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType);\r\n  }\r\n\r\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>,\r\n                              selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Worksheet.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { SheetPath } from '@tableau/api-internal-contract';\r\n\r\nimport { SheetInfoImpl } from './SheetInfoImpl';\r\n\r\nimport { ParametersService } from '../Services/ParametersService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\n\r\nexport class SheetImpl {\r\n  public constructor(private _sheetInfoImpl: SheetInfoImpl) {\r\n  }\r\n\r\n  public get name(): string {\r\n    return this._sheetInfoImpl.name;\r\n  }\r\n\r\n  public get sheetType(): Contract.SheetType {\r\n    return this._sheetInfoImpl.sheetType;\r\n  }\r\n\r\n  public get sheetPath(): SheetPath {\r\n    return this._sheetInfoImpl.sheetPath;\r\n  }\r\n\r\n  public get size(): Contract.Size {\r\n    return this._sheetInfoImpl.sheetSize;\r\n  }\r\n\r\n  public findParameterAsync(parameterName: string, sheet: Contract.Sheet): Promise<Contract.Parameter | undefined> {\r\n    const service = ApiServiceRegistry.instance.getService<ParametersService>(ServiceNames.Parameters);\r\n    return service.findParameterByNameAsync(parameterName, sheet);\r\n  }\r\n\r\n  public getParametersAsync(sheet: Contract.Sheet): Promise<Array<Contract.Parameter>> {\r\n    const service = ApiServiceRegistry.instance.getService<ParametersService>(ServiceNames.Parameters);\r\n    return service.getParametersForSheetAsync(this.sheetPath, sheet);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/SheetImpl.ts\n **/","import { TableauException } from '@tableau/api-utils';\r\n/**\r\n * Base interface for an api service\r\n */\r\nexport interface ApiService {\r\n  /**\r\n   * Gets the name for this service.\r\n   */\r\n  readonly serviceName: string;\r\n}\r\n\r\n/**\r\n * Collection of service name which will be registered in the api-shared project\r\n */\r\nexport const enum ServiceNames {\r\n  DataSourceService = 'data-source-service',\r\n  GetData = 'get-data-service',\r\n  Filter = 'filter-service',\r\n  Notification = 'notification-service',\r\n  Parameters = 'parameters-service',\r\n  Selection = 'selection-service'\r\n}\r\n\r\n/**\r\n * Do some globabl declarations so we can create a singleton on the window object\r\n */\r\ndeclare global {\r\n  interface Window { __tableauApiServiceRegistry: ServiceRegistry | undefined; }\r\n}\r\n\r\nexport interface ServiceRegistry {\r\n  /**\r\n   * Registers a new service into the service registry. Any existing one will\r\n   * be overwritten. the service is registered under service.serviceName\r\n   *\r\n   * @param {ApiService} service The servive to register\r\n   */\r\n  registerService(service: ApiService): void;\r\n\r\n  /**\r\n   * Retrieves the given service from the registry. If there is not a\r\n   * service registered under that name, throws and error\r\n   *\r\n   * @template T The type of the service\r\n   * @param {string} serviceName The name of the service.\r\n   * @returns {T} The requested service\r\n   */\r\n  getService<T extends ApiService>(serviceName: string): T;\r\n}\r\n\r\nclass ServiceRegistryImpl implements ServiceRegistry {\r\n  private static SERVICE_NOT_REGISTERED: string = 'No Service %1 is registered';\r\n  private _services: { [serviceName: string]: ApiService; };\r\n\r\n  public constructor() {\r\n    this._services = {};\r\n  }\r\n\r\n  public registerService(service: ApiService): void {\r\n    this._services[service.serviceName] = service;\r\n  }\r\n\r\n  public getService<T extends ApiService>(serviceName: string): T {\r\n    if (!this._services.hasOwnProperty(serviceName)) {\r\n      throw TableauException.error(ServiceRegistryImpl.SERVICE_NOT_REGISTERED, [serviceName]);\r\n    }\r\n\r\n    return this._services[serviceName] as T;\r\n  }\r\n}\r\n\r\n/**\r\n * static class used for getting access to the single instance\r\n * of the ApiServiceRegistry\r\n */\r\nexport class ApiServiceRegistry {\r\n  private static SERVICE_REGISTRY_FAILED: string = 'Assigning service registry failed';\r\n  /**\r\n   * Gets the singleton instance of the ServiceRegistry\r\n   */\r\n  public static get instance(): ServiceRegistry {\r\n    if (!window.__tableauApiServiceRegistry) {\r\n      ApiServiceRegistry.setInstance(new ServiceRegistryImpl());\r\n    }\r\n\r\n    if (!window.__tableauApiServiceRegistry) {\r\n      throw TableauException.error(ApiServiceRegistry.SERVICE_REGISTRY_FAILED);\r\n    }\r\n\r\n    return window.__tableauApiServiceRegistry;\r\n  }\r\n\r\n  /**\r\n   * Helper method to override the registry instance. Can be used by unit tests\r\n   *\r\n   * @param {ServiceRegistry} serviceRegistry The new registry\r\n   */\r\n  public static setInstance(serviceRegistry?: ServiceRegistry): void {\r\n    window.__tableauApiServiceRegistry = serviceRegistry;\r\n  }\r\n\r\n  // Private to avoid anyone constructing this\r\n  private constructor() {}\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/ServiceRegistry.ts\n **/","import { SheetType, Size } from '@tableau/api-external-contract';\r\nimport { SheetPath } from '@tableau/api-internal-contract';\r\n\r\nexport class SheetInfoImpl {\r\n  public constructor(\r\n    private _name: string,\r\n    private _sheetType: SheetType,\r\n    private _sheetSize: Size\r\n  ) { }\r\n\r\n  public get name(): string {\r\n    return this._name;\r\n  }\r\n\r\n  public get sheetSize(): Size {\r\n    return this._sheetSize;\r\n  }\r\n\r\n  public get sheetType(): SheetType {\r\n    return this._sheetType;\r\n  }\r\n\r\n  public get sheetPath(): SheetPath {\r\n    return {\r\n      sheetName: this.name,\r\n      isDashboard: this.sheetType === SheetType.Dashboard\r\n      // TODO - Stories\r\n    };\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/SheetInfoImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport {\r\n  DataSchema,\r\n  DataSource as DataSourceInfo,\r\n  FilterEvent, NotificationId,\r\n  VisualId,\r\n  WorksheetDataSourceInfo\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport { DataSource } from '../DataSource';\r\nimport { Worksheet } from '../Worksheet';\r\n\r\nimport { DataSourceImpl } from './DataSourceImpl';\r\nimport { SheetImpl } from './SheetImpl';\r\nimport { SheetInfoImpl } from './SheetInfoImpl';\r\nimport { SingleEventManagerImpl } from './SingleEventManagerImpl';\r\n\r\nimport { FilterChangedEvent } from '../Events/FilterChangedEvent';\r\nimport { MarksSelectedEvent } from '../Events/MarksSelectedEvent';\r\nimport { SingleEventManager } from '../SingleEventManager';\r\n\r\nimport { DataSourceService } from '../Services/DataSourceService';\r\nimport { FilterService } from '../Services/FilterService';\r\nimport { GetDataService, GetDataType } from '../Services/GetDataService';\r\nimport { NotificationService } from '../Services/NotificationService';\r\nimport { SelectionService } from '../Services/SelectionService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\n\r\nconst visualIdsAreEqual = function(a: VisualId, b: VisualId): boolean {\r\n  return a && b &&\r\n    a.worksheet === b.worksheet &&\r\n    a.dashboard === b.dashboard &&\r\n    a.storyboard === b.storyboard &&\r\n    a.storyPointID === b.storyPointID &&\r\n    a.flipboardZoneID === b.flipboardZoneID;\r\n};\r\n\r\nexport class WorksheetImpl extends SheetImpl {\r\n  public constructor(sheetInfoImpl: SheetInfoImpl,\r\n                     private _visualId: VisualId,\r\n                     private _parentDashboard: Contract.Dashboard) {\r\n    super(sheetInfoImpl);\r\n  }\r\n\r\n  public get parentDashboard(): Contract.Dashboard {\r\n    return this._parentDashboard;\r\n  }\r\n\r\n  /**\r\n   * Helper method which goes through and registers each event type this impl knows about\r\n   * with the NotificationService. It returns an array of SingleEventManager objects which\r\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\r\n   *\r\n   * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications\r\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\r\n   */\r\n  public initializeEvents(worksheet: Worksheet): Array<SingleEventManager> {\r\n    const results = new Array<SingleEventManager>();\r\n    let notificationService: NotificationService;\r\n\r\n    try {\r\n      notificationService = ApiServiceRegistry.instance.getService<NotificationService>(ServiceNames.Notification);\r\n    } catch (e) {\r\n      // If we don't have this service registered, just return\r\n      return results;\r\n    }\r\n\r\n    // Initialize all of the event managers we'll need (one for each event type)\r\n    const marksEvent = new SingleEventManagerImpl<MarksSelectedEvent>(Contract.TableauEventType.MarkSelectionChanged);\r\n    notificationService.registerHandler(NotificationId.SelectedMarksChanged, (model) => {\r\n      const visualId = model as VisualId;\r\n      return visualIdsAreEqual(visualId, this.visualId);\r\n    }, (viz: VisualId) => {\r\n      marksEvent.triggerEvent(() => new MarksSelectedEvent(worksheet));\r\n    });\r\n\r\n    const filterEvent = new SingleEventManagerImpl<FilterChangedEvent>(Contract.TableauEventType.FilterChanged);\r\n    notificationService.registerHandler(NotificationId.FilterChanged, (model) => {\r\n      const filterEventResponse = model as FilterEvent;\r\n      return this.visualId.worksheet === filterEventResponse.visualId.worksheet;\r\n    }, (event: FilterEvent) => {\r\n      filterEvent.triggerEvent(() => new FilterChangedEvent(worksheet, event.fieldName));\r\n    });\r\n\r\n    results.push(marksEvent);\r\n    results.push(filterEvent);\r\n\r\n    // TODO - other event types\r\n\r\n    return results;\r\n  }\r\n\r\n  public get visualId(): VisualId {\r\n    return this._visualId;\r\n  }\r\n\r\n  public applyFilterAsync(\r\n    fieldName: string, values: Array<string>, updateType: Contract.FilterUpdateType, options: Contract.FilterOptions): Promise<string> {\r\n      const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n      return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options);\r\n    }\r\n\r\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\r\n    const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n    return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions);\r\n  }\r\n\r\n  public clearFilterAsync(fieldName: string): Promise<string> {\r\n    const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n    return service.clearFilterAsync(this.visualId, fieldName);\r\n  }\r\n\r\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\r\n    const service = ApiServiceRegistry.instance.getService<DataSourceService>(ServiceNames.DataSourceService);\r\n\r\n    return service.getDataSourcesAsync().then<Array<Contract.DataSource>>(result => {\r\n      const dataSchema: DataSchema = result as DataSchema;\r\n      const worksheetDataSourceInfo: WorksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[this.name];\r\n\r\n      let dataSources: Array<Contract.DataSource> = [];\r\n\r\n      // First, add the primary datasource.  By convention, it comes first in the returned array.\r\n      let primaryId: string = worksheetDataSourceInfo.primaryDataSource;\r\n      dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[primaryId]));\r\n\r\n      // Then, loop through any secondary data sources and add them.\r\n      for (let secondaryId of worksheetDataSourceInfo.referencedDataSourceList) {\r\n        if (secondaryId !== primaryId) {\r\n          dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId]));\r\n        }\r\n      }\r\n\r\n      return dataSources;\r\n    });\r\n  }\r\n\r\n  public getFiltersAsync(): Promise<Contract.Filter[]> {\r\n    const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n    return service.getFiltersAsync(this.visualId);\r\n  }\r\n\r\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\r\n    const service = ApiServiceRegistry.instance.getService<GetDataService>(ServiceNames.GetData);\r\n    return service.getSelectedMarksAsync(this.visualId);\r\n  }\r\n\r\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\r\n    const service = ApiServiceRegistry.instance.getService<GetDataService>(ServiceNames.GetData);\r\n    return service.getHighlightedMarksAsync(this.visualId);\r\n  }\r\n\r\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\r\n    const service = ApiServiceRegistry.instance.getService<GetDataService>(ServiceNames.GetData);\r\n    options = options || {};\r\n\r\n    return service.getUnderlyingDataAsync(\r\n      this.visualId, GetDataType.Summary, !!options.ignoreAliases, !!options.ignoreSelection, true, 0);\r\n    }\r\n\r\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\r\n    const service = ApiServiceRegistry.instance.getService<GetDataService>(ServiceNames.GetData);\r\n    options = options || {};\r\n    return service.getUnderlyingDataAsync(\r\n      this.visualId,\r\n      GetDataType.Underlying,\r\n      !!options.ignoreAliases,\r\n      !!options.ignoreSelection,\r\n      !!options.includeAllColumns,\r\n      options.maxRows || 0);\r\n  }\r\n\r\n  public clearSelectedMarksAsync(): Promise<void> {\r\n    const service = ApiServiceRegistry.instance.getService<SelectionService>(ServiceNames.Selection);\r\n    return service.clearSelectedMarksAsync(this.visualId);\r\n  }\r\n\r\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>,\r\n                                 selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    const service = ApiServiceRegistry.instance.getService<SelectionService>(ServiceNames.Selection);\r\n    return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType);\r\n  }\r\n\r\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>,\r\n                              selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    const service = ApiServiceRegistry.instance.getService<SelectionService>(ServiceNames.Selection);\r\n    return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType);\r\n  }\r\n\r\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): Contract.DataSource {\r\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo);\r\n    const dataSource = new DataSource(dataSourceImpl);\r\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\r\n    return dataSource;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/WorksheetImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { DataSourceImpl } from './Impl/DataSourceImpl';\r\n\r\nexport class DataSource implements Contract.DataSource {\r\n  public constructor(private _dataSourceImpl: DataSourceImpl) { }\r\n\r\n  public get name(): string {\r\n    return this._dataSourceImpl.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._dataSourceImpl.id;\r\n  }\r\n\r\n  public get fields(): Contract.Field[] {\r\n    return this._dataSourceImpl.fields;\r\n  }\r\n\r\n  public get extractUpdateTime(): string | undefined {\r\n    return this._dataSourceImpl.extractUpdateTime;\r\n  }\r\n\r\n  public get isExtract(): boolean {\r\n    return this._dataSourceImpl.isExtract;\r\n  }\r\n\r\n  public refreshAsync(): Promise<void> {\r\n    return this._dataSourceImpl.refreshAsync();\r\n  }\r\n\r\n  public getActiveTablesAsync(): Promise<Contract.TableSummary[]> {\r\n    return this._dataSourceImpl.getActiveTablesAsync();\r\n  }\r\n\r\n  public getConnectionSummariesAsync(): Promise<Contract.ConnectionSummary[]> {\r\n    return this._dataSourceImpl.getConnectionSummariesAsync();\r\n  }\r\n\r\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions):\r\n    Promise<Contract.DataTable> {\r\n    return this._dataSourceImpl.getUnderlyingDataAsync(options);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/DataSource.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport * as InternalContract from '@tableau/api-internal-contract';\r\n\r\nimport { FieldImpl } from './FieldImpl';\r\n\r\nimport { ConnectionSummary } from '../ConnectionSummary';\r\nimport { Field } from '../Field';\r\nimport { TableSummary } from '../TableSummary';\r\n\r\nimport { DataSourceService } from '../Services/DataSourceService';\r\nimport { GetDataService } from '../Services/GetDataService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\n\r\nexport class DataSourceImpl {\r\n  private _fields: Field[];\r\n\r\n  public constructor(private _dataSourceInfo: InternalContract.DataSource) {\r\n    this._fields = _dataSourceInfo.fields.map(fieldModel => {\r\n      const fieldImpl = new FieldImpl(fieldModel, this);\r\n      return new Field(fieldImpl);\r\n    });\r\n   }\r\n\r\n  public get name(): string {\r\n    return this._dataSourceInfo.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._dataSourceInfo.id;\r\n  }\r\n\r\n  public get extractUpdateTime(): string | undefined {\r\n    return this._dataSourceInfo.extractUpdateTime;\r\n  }\r\n\r\n  public get fields(): Contract.Field[] {\r\n    return this._fields;\r\n  }\r\n\r\n  public get isExtract(): boolean {\r\n    return this._dataSourceInfo.isExtract;\r\n  }\r\n\r\n  public refreshAsync(): Promise<void> {\r\n    const dataSourceService = ApiServiceRegistry.instance.getService<DataSourceService>(\r\n      ServiceNames.DataSourceService);\r\n\r\n    return dataSourceService.refreshAsync(this._dataSourceInfo.id);\r\n  }\r\n\r\n  public getConnectionSummariesAsync(): Promise<Contract.ConnectionSummary[]> {\r\n    const dataSourceService = ApiServiceRegistry.instance.getService<DataSourceService>(\r\n      ServiceNames.DataSourceService);\r\n\r\n    return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then<Contract.ConnectionSummary[]>(summaries => {\r\n      return summaries.map(summary => new ConnectionSummary(summary));\r\n    });\r\n  }\r\n\r\n  public getActiveTablesAsync(): Promise<Contract.TableSummary[]> {\r\n    const dataSourceService = ApiServiceRegistry.instance.getService<DataSourceService>(\r\n      ServiceNames.DataSourceService);\r\n\r\n    return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then<Contract.TableSummary[]>(tableInfos => {\r\n      return tableInfos.map(tableInfo => new TableSummary(tableInfo));\r\n    });\r\n  }\r\n\r\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions):\r\n    Promise<Contract.DataTable> {\r\n      const defaultOptions = {\r\n          ignoreAliases: false,\r\n          maxRows: 10000,\r\n          columnsToInclude: [],\r\n      };\r\n\r\n      options = options || {};\r\n\r\n      const getDataService = ApiServiceRegistry.instance.getService<GetDataService>(ServiceNames.GetData);\r\n      return getDataService.getDataSourceDataAsync(\r\n        this.id,\r\n        !!options.ignoreAliases,\r\n        options.maxRows || defaultOptions.maxRows,\r\n        options.columnsToInclude || defaultOptions.columnsToInclude);\r\n  }\r\n\r\n  public initializeWithPublicInterfaces(dataSource: Contract.DataSource): void {\r\n    this._fields = this._dataSourceInfo.fields.map(fieldModel => {\r\n      const fieldImpl = new FieldImpl(fieldModel, dataSource);\r\n      return new Field(fieldImpl);\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/DataSourceImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport * as InternalContract from '@tableau/api-internal-contract';\r\n\r\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\r\n\r\nexport class FieldImpl {\r\n  public constructor(private _fieldInfo: InternalContract.Field,\r\n                     private _parentDataSource: Contract.DataSource) {  }\r\n\r\n  public get name(): string {\r\n    return this._fieldInfo.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._fieldInfo.id;\r\n  }\r\n\r\n  public get description(): string | undefined {\r\n    return this._fieldInfo.description;\r\n  }\r\n\r\n  public get aggregation(): Contract.FieldAggregationType {\r\n    return InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation);\r\n  }\r\n\r\n  public get dataSource(): Contract.DataSource {\r\n    return this._parentDataSource;\r\n  }\r\n\r\n  public get role(): Contract.FieldRoleType {\r\n    return InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role);\r\n  }\r\n\r\n  public get isHidden(): boolean {\r\n    return this._fieldInfo.isHidden;\r\n  }\r\n\r\n  public get isGenerated(): boolean {\r\n    return this._fieldInfo.isGenerated;\r\n  }\r\n\r\n  public get isCalculatedField(): boolean {\r\n    return this._fieldInfo.isCalculatedField;\r\n  }\r\n\r\n  public get isCombinedField(): boolean {\r\n    return this._fieldInfo.isCombinedField;\r\n  }\r\n\r\n  public getCalculatedFieldAsync(): Promise<Contract.CalculatedField | undefined> {\r\n    throw new Error('Field getCalculatedFieldAsync method not yet implemented.');\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/FieldImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { ConnectionDescriptionSummary } from '@tableau/api-internal-contract';\r\n\r\n/**\r\n * Implementation of a connection summary.\r\n * This does not follow the Impl pattern as it is just a property bag.\r\n */\r\nexport class ConnectionSummary implements Contract.ConnectionSummary {\r\n  public constructor(private _connectionInfo: ConnectionDescriptionSummary) { }\r\n\r\n  public get name(): string {\r\n    return this._connectionInfo.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._connectionInfo.id;\r\n  }\r\n\r\n  public get serverURI(): string {\r\n    return this._connectionInfo.serverURI;\r\n  }\r\n\r\n  public get type(): string {\r\n    return this._connectionInfo.type;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/ConnectionSummary.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\nimport { FieldImpl } from './Impl/FieldImpl';\r\n\r\nexport class Field implements Contract.Field {\r\n  public constructor(private _fieldImpl: FieldImpl) { }\r\n\r\n  public get name(): string {\r\n    return this._fieldImpl.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._fieldImpl.id;\r\n  }\r\n\r\n  public get description(): string | undefined {\r\n    return this._fieldImpl.description;\r\n  }\r\n\r\n  public get aggregation(): Contract.FieldAggregationType {\r\n    return this._fieldImpl.aggregation;\r\n  }\r\n\r\n  public get dataSource(): Contract.DataSource {\r\n    return this._fieldImpl.dataSource;\r\n  }\r\n\r\n  public get role(): Contract.FieldRoleType {\r\n    return this._fieldImpl.role;\r\n  }\r\n\r\n  public get isHidden(): boolean {\r\n    return this._fieldImpl.isHidden;\r\n  }\r\n\r\n  public get isGenerated(): boolean {\r\n    return this._fieldImpl.isGenerated;\r\n  }\r\n\r\n  public get isCalculatedField(): boolean {\r\n    return this._fieldImpl.isCalculatedField;\r\n  }\r\n\r\n  public get columnType(): Contract.ColumnType {\r\n    throw TableauException.apiNotImplemented(['Field.columnType']);\r\n  }\r\n\r\n  public get isCombinedField(): boolean {\r\n    return this._fieldImpl.isCombinedField;\r\n  }\r\n\r\n  public getCalculatedFieldAsync(): Promise<Contract.CalculatedField | undefined> {\r\n    return this._fieldImpl.getCalculatedFieldAsync();\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Field.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableInfo } from '@tableau/api-internal-contract';\r\n\r\n/**\r\n * Implementation of a table summary.\r\n * This does not follow the Impl pattern as it is just a property bag.\r\n */\r\nexport class TableSummary implements Contract.TableSummary {\r\n  public constructor(private _tableInfo: TableInfo) { }\r\n\r\n  public get name(): string {\r\n    return this._tableInfo.name;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._tableInfo.id;\r\n  }\r\n\r\n  public get connectionId(): string {\r\n    return this._tableInfo.connectionId;\r\n  }\r\n\r\n  public get customSQL(): string | undefined {\r\n    return this._tableInfo.customSQL;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/TableSummary.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { SingleEventManager } from '../SingleEventManager';\r\n\r\n/**\r\n * This class implements the SingleEventManager interface for a single type of Tableau event\r\n *\r\n * @template TEventType The Tableau event type this class specializes\r\n */\r\nexport class SingleEventManagerImpl<TEventType extends Contract.TableauEvent> implements SingleEventManager {\r\n  private _eventType: Contract.TableauEventType;\r\n  private _handlers: Array<(eventObj: TEventType) => void>;\r\n\r\n  public constructor(eventType: Contract.TableauEventType) {\r\n    this._eventType = eventType;\r\n    this._handlers = [];\r\n  }\r\n\r\n  public get eventType(): Contract.TableauEventType {\r\n    return this._eventType;\r\n  }\r\n\r\n  public addEventListener(handler: (eventObj: TEventType) => void): Contract.TableauEventUnregisterFn {\r\n    this._handlers.push(handler);\r\n    return () => this.removeEventListener(handler);\r\n  }\r\n\r\n  public removeEventListener(handler: (eventObj: TEventType) => void): boolean {\r\n    const beforeCount = this._handlers.length;\r\n    this._handlers = this._handlers.filter(h => h !== handler);\r\n    return beforeCount > this._handlers.length;\r\n  }\r\n\r\n  public triggerEvent(eventGenerator: () => TEventType): void {\r\n    for (const handler of this._handlers) {\r\n      try {\r\n        const eventModel = eventGenerator();\r\n        handler(eventModel);\r\n      } catch (e) {\r\n        // Since this handler could be outside our control, just catch anything it throws and continue on\r\n        continue;\r\n      }\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/SingleEventManagerImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\r\n\r\nexport class FilterChangedEvent extends TableauWorksheetEvent implements Contract.FilterChangedEvent {\r\n  public constructor(worksheet: Contract.Worksheet, private _fieldName: string) {\r\n    super(Contract.TableauEventType.FilterChanged, worksheet);\r\n  }\r\n\r\n  public get fieldName(): string {\r\n    return this._fieldName;\r\n  }\r\n\r\n  public getFilterAsync(): Promise<Contract.Filter> {\r\n    return this._worksheet.getFiltersAsync().then<Contract.Filter>(filters => {\r\n      // TODO: Filtering of the filters should eventually be done platform side.\r\n      const eventedFilter = filters.find((filter) => (filter.fieldName === this._fieldName));\r\n\r\n      if (!eventedFilter) {\r\n        // We shouldn't hit this unless the filter was removed from the worksheet\r\n        // after the event was raised.\r\n        throw TableauException.internalError(['Filter no longer found in worksheet.']);\r\n      }\r\n\r\n      return eventedFilter;\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/FilterChangedEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { TableauSheetEvent } from './TableauSheetEvent';\r\n\r\nexport class TableauWorksheetEvent extends TableauSheetEvent implements Contract.TableauWorksheetEvent {\r\n  public get worksheet(): Contract.Worksheet {\r\n    return this._worksheet;\r\n  }\r\n\r\n  public constructor(type: Contract.TableauEventType, protected _worksheet: Contract.Worksheet) {\r\n    super(type, _worksheet);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/TableauWorksheetEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { TableauEvent } from './TableauEvent';\r\n\r\nexport class TableauSheetEvent extends TableauEvent implements Contract.TableauSheetEvent {\r\n  private _sheet: Contract.Sheet;\r\n\r\n  public get sheet(): Contract.Sheet {\r\n    return this._sheet;\r\n  }\r\n\r\n  public constructor(type: Contract.TableauEventType, sheet: Contract.Sheet) {\r\n    super(type);\r\n\r\n    this._sheet = sheet;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/TableauSheetEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nexport class TableauEvent implements Contract.TableauEvent {\r\n  private _type: Contract.TableauEventType;\r\n\r\n  public constructor(type: Contract.TableauEventType) {\r\n    this._type = type;\r\n  }\r\n\r\n  public get type(): Contract.TableauEventType {\r\n    return this._type;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/TableauEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\r\n\r\nexport class MarksSelectedEvent extends TableauWorksheetEvent implements Contract.MarksSelectedEvent {\r\n  public constructor(worksheet: Contract.Worksheet) {\r\n    super(Contract.TableauEventType.MarkSelectionChanged, worksheet);\r\n  }\r\n\r\n  public getMarksAsync(): Promise<Contract.MarksCollection> {\r\n    return this.worksheet.getSelectedMarksAsync();\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/MarksSelectedEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { VisualId } from '@tableau/api-internal-contract';\r\n\r\nimport { ApiService } from './ServiceRegistry';\r\n\r\n/**\r\n * Defines which type of getData call to make.\r\n */\r\nexport enum GetDataType {\r\n  Summary = 'summary',\r\n  Underlying = 'underlying'\r\n}\r\n\r\n/**\r\n * Service for implementing the logic for various getData calls\r\n *\r\n * @interface GetDataService\r\n * @extends {ApiService}\r\n */\r\nexport interface GetDataService extends ApiService {\r\n  /**\r\n   * Gets the underlying data for a particular visual\r\n   *\r\n   * @param {VisualId} visualId  The visual to get data for\r\n   * @param {GetDataType} getType  The type of getData call to make\r\n   * @param {boolean} ignoreAliases  Whether or not aliases should be ignored\r\n   * @param {boolean} ignoreSelection  Whether or not selection should be ignored\r\n   * @param {boolean} includeAllColumns  Should all columns be included\r\n   * @param {number} maxRows  Maximum number of rows to return\r\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\r\n   */\r\n    getUnderlyingDataAsync(\r\n      visualId: VisualId,\r\n      getType: GetDataType,\r\n      ignoreAliases: boolean,\r\n      ignoreSelection: boolean,\r\n      includeAllColumns: boolean,\r\n      maxRows: number): Promise<Contract.DataTable>;\r\n\r\n    /**\r\n     * Gets the currently selected marks for a given visual\r\n     *\r\n    * @param {VisualId} visualId  The visual to get data for\r\n    * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\r\n    */\r\n    getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\r\n\r\n    /**\r\n     * Gets the currently highlighted marks for a given visual\r\n     *\r\n    * @param {VisualId} visualId  The visual to get data for\r\n    * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\r\n    */\r\n    getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\r\n\r\n    /**\r\n     * @param {string} datasourceId  The id of the datasource to get data for\r\n     * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\r\n     * @param {number} maxRows The maximum number of rows to retrieve\r\n     * @param {Array<string>} columnsToInclude  Collection of column captions which should be returned. Empty means all columns\r\n     * @returns {Promise<Contract.DataTable>}  Data table with the requested data\r\n     */\r\n    getDataSourceDataAsync(\r\n      datasourceId: string,\r\n      ignoreAliases: boolean,\r\n      maxRows: number,\r\n      columnsToInclude: Array<string>): Promise<Contract.DataTable>;\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/GetDataService.ts\n **/","import { InternalApiDispatcher } from '@tableau/api-internal-contract';\r\n\r\nimport { DataSourceServiceImpl } from './impl/DataSourceServiceImpl';\r\nimport { FilterServiceImpl } from './impl/FilterServiceImpl';\r\nimport { GetDataServiceImpl } from './impl/GetDataServiceImpl';\r\nimport { NotificationServiceImpl } from './impl/NotificationServiceImpl';\r\nimport { ParametersServiceImpl } from './impl/ParametersServiceImpl';\r\nimport { SelectionServiceImpl } from './impl/SelectionServiceImpl';\r\nimport { ApiServiceRegistry } from './ServiceRegistry';\r\n\r\nexport function registerAllSharedServices(dispatcher: InternalApiDispatcher): void {\r\n  ApiServiceRegistry.instance.registerService(new DataSourceServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new GetDataServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new FilterServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new NotificationServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new ParametersServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new SelectionServiceImpl(dispatcher));\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/RegisterAllSharedServices.ts\n **/","import { ErrorCodes } from '@tableau/api-external-contract';\r\nimport {\r\n  ConnectionDescriptionSummary,\r\n  DataSchema,\r\n  ExecuteParameters,\r\n  InternalApiDispatcher,\r\n  JoinDescription,\r\n  ParameterId,\r\n  TableInfo,\r\n  VerbId\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { DataSourceService } from '../DataSourceService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nexport class DataSourceServiceImpl implements DataSourceService {\r\n  public constructor(private _dispatcher: InternalApiDispatcher) { }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.DataSourceService;\r\n  }\r\n\r\n  public refreshAsync(dataSourceId: string): Promise<void> {\r\n    const parameters: ExecuteParameters = {[ParameterId.DataSourceId]: dataSourceId};\r\n\r\n    return this._dispatcher.execute(VerbId.RefreshDataSource, parameters).then<void>(response => {\r\n      return;\r\n    });\r\n  }\r\n\r\n  public getActiveTablesAsync(dataSourceId: string): Promise<TableInfo[]> {\r\n    const joinParameters: ExecuteParameters = {[ParameterId.DataSourceId]: dataSourceId};\r\n\r\n    // Get the description of the tables used by this connection\r\n    return this._dispatcher.execute(VerbId.GetJoinDescription, joinParameters).then<TableInfo[]>(joinResponse => {\r\n      const joinDescription = joinResponse.result as JoinDescription;\r\n\r\n      // getActiveTables is unsupported for cubes and GA. We do not have a connection type property\r\n      // available from the platform (intentionally, to reduce code churn as new connections are added).\r\n      // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource.\r\n      if (joinDescription.tables.length === 0) {\r\n        throw TableauException.error('getActiveTablesAsync is unsupported for DataSource.',\r\n                                      [ErrorCodes.UnsupportedMethodForDataSourceType]);\r\n      }\r\n\r\n      return joinDescription.tables;\r\n    });\r\n  }\r\n\r\n  public getDataSourcesAsync(): Promise<DataSchema> {\r\n    return this._dispatcher.execute(VerbId.GetDataSources, {}).then<DataSchema>(response => {\r\n      const dataSchema = response.result as DataSchema;\r\n      return dataSchema;\r\n    });\r\n  }\r\n\r\n  public getConnectionSummariesAsync(dataSourceId: string): Promise<ConnectionDescriptionSummary[]> {\r\n    const params: ExecuteParameters = {[ParameterId.DataSourceId]: dataSourceId};\r\n\r\n    // Get the description of the tables used by this connection\r\n    return this._dispatcher.execute(VerbId.GetConnectionDescriptionSummaries, params).then<ConnectionDescriptionSummary[]>(response => {\r\n      const descriptionSummaries = response.result as ConnectionDescriptionSummary[];\r\n      return descriptionSummaries;\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/DataSourceServiceImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport * as InternalContract from '@tableau/api-internal-contract';\r\nimport {\r\n  CommandError,\r\n  ExecuteParameters,\r\n  FilterType,\r\n  InternalApiDispatcher,\r\n  ParameterId,\r\n  VerbId,\r\n  VisualId\r\n} from '@tableau/api-internal-contract';\r\nimport { Param, TableauException } from '@tableau/api-utils';\r\n\r\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\r\nimport { InternalToExternalEnumMappings as InternalEnumConverter } from '../../EnumMappings/InternalToExternalEnumMappings';\r\nimport {\r\n  CategoricalDomain,\r\n  CategoricalFilter,\r\n  RangeDomain,\r\n  RangeFilter,\r\n  RelativeDateFilter\r\n} from '../../Models/FilterModels';\r\nimport { DataValue } from '../../Models/GetDataModels';\r\n\r\nimport { FilterService } from '../FilterService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nexport class FilterServiceImpl implements FilterService {\r\n  private static FILTER_ERROR: string = 'Error Applying Filter: %1';\r\n  private _dispatcher: InternalApiDispatcher;\r\n\r\n  public constructor(dispatcher: InternalApiDispatcher) {\r\n    this._dispatcher = dispatcher;\r\n  }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.Filter;\r\n  }\r\n\r\n  public applyFilterAsync(\r\n    visualId: VisualId,\r\n    fieldName: string,\r\n    values: Array<string>,\r\n    updateType: Contract.FilterUpdateType,\r\n    filterOptions: Contract.FilterOptions): Promise<string> {\r\n      if (!Param.isValidEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType)) {\r\n        throw TableauException.invalidParamValue(['FilterUpdateType']);\r\n      }\r\n      const verb = VerbId.ApplyCategoricalFilter;\r\n      const parameters: ExecuteParameters = {};\r\n      parameters[ParameterId.VisualId] = visualId;\r\n      parameters[ParameterId.FieldName] = fieldName;\r\n      parameters[ParameterId.FilterValues] = values;\r\n      parameters[ParameterId.FilterUpdateType] = updateType;\r\n      parameters[ParameterId.IsExcludeMode] =\r\n        (filterOptions === undefined || filterOptions.isExcludeMode === undefined) ? false : filterOptions.isExcludeMode;\r\n\r\n      return this._dispatcher.execute(verb, parameters).then<string>(response => {\r\n        const error = response.result as CommandError;\r\n        if (!(error.errorCode === null || error.errorCode === undefined)) {\r\n          // TODO: come back and implement error handling logic\r\n          throw TableauException.error(FilterServiceImpl.FILTER_ERROR, [error.errorCode]);\r\n        }\r\n        return fieldName;\r\n      });\r\n    }\r\n\r\n  public applyRangeFilterAsync(visualId: VisualId, fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\r\n    if (!filterOptions) {\r\n      throw TableauException.missingParameter(['RangeFilterOptions']);\r\n    }\r\n    Param.verifyRangeParamType(filterOptions.min, filterOptions.max);\r\n\r\n    const verb = VerbId.ApplyRangeFilter;\r\n    const parameters: ExecuteParameters = {};\r\n\r\n    if (filterOptions.min) {\r\n      let min: string | number;\r\n      if (filterOptions.min instanceof Date) {\r\n        min = Param.serializeDateForPlatform(filterOptions.min);\r\n      } else {\r\n        min = filterOptions.min;\r\n      }\r\n      parameters[ParameterId.FilterRangeMin] = min;\r\n    }\r\n\r\n    if (filterOptions.max) {\r\n      let max: string | number;\r\n      if (filterOptions.max instanceof Date) {\r\n        max = Param.serializeDateForPlatform(filterOptions.max);\r\n      } else {\r\n        max = filterOptions.max;\r\n      }\r\n      parameters[ParameterId.FilterRangeMax] = max;\r\n    }\r\n\r\n    if (filterOptions.nullOption) {\r\n      if (!Param.isValidEnumValue<Contract.FilterNullOption>(filterOptions.nullOption, Contract.FilterNullOption)) {\r\n        throw TableauException.invalidParamValue(['NullOption']);\r\n      }\r\n      parameters[ParameterId.FilterRangeNullOption] = ExternalEnumConverter.nullOptions.convert(filterOptions.nullOption);\r\n    }\r\n    parameters[ParameterId.FieldName] = fieldName;\r\n    parameters[ParameterId.VisualId] = visualId;\r\n\r\n    return this._dispatcher.execute(verb, parameters).then<string>(response => {\r\n      return fieldName;\r\n    });\r\n  }\r\n\r\n  public clearFilterAsync(visualId: VisualId, fieldName: string): Promise<string> {\r\n    const verb = VerbId.ClearFilter;\r\n    let parameters: ExecuteParameters = {};\r\n    parameters[ParameterId.VisualId] = visualId;\r\n    parameters[ParameterId.FieldName] = fieldName;\r\n    return this._dispatcher.execute(verb, parameters).then<string>(resposne => {\r\n      return fieldName;\r\n    });\r\n  }\r\n\r\n  public getFiltersAsync(visualId: VisualId): Promise<Contract.Filter[]> {\r\n    const verb = VerbId.GetFilters;\r\n    let parameters: ExecuteParameters = {};\r\n    parameters[ParameterId.VisualId] = visualId;\r\n    return this._dispatcher.execute(verb, parameters).then<Contract.Filter[]>(response => {\r\n      let filters = response.result as InternalContract.Filter[];\r\n      return this.convertDomainFilters(filters);\r\n    });\r\n  }\r\n\r\n  public getCategoricalDomainAsync(\r\n    worksheetName: string,\r\n    fieldId: string,\r\n    domainType: Contract.FilterDomainType): Promise<Contract.CategoricalDomain> {\r\n    if (!Param.isValidEnumValue<Contract.FilterDomainType>(domainType, Contract.FilterDomainType)) {\r\n      throw new Error('Invalid value for parameter FilterDomainType');\r\n    }\r\n    const verb = VerbId.GetCategoricalDomain;\r\n    let parameters: ExecuteParameters = {};\r\n    parameters[ParameterId.VisualId] = {\r\n      worksheet: worksheetName\r\n    };\r\n    parameters[ParameterId.FieldId] = fieldId;\r\n    parameters[ParameterId.DomainType] = domainType;\r\n    return this._dispatcher.execute(verb, parameters).then<Contract.CategoricalDomain>(response => {\r\n      let domain = response.result as InternalContract.CategoricalDomain;\r\n      return this.convertCategoricalDomain(domain, domainType);\r\n    });\r\n  }\r\n\r\n  public getRangeDomainAsync(worksheetName: string, fieldId: string, domainType: Contract.FilterDomainType): Promise<Contract.RangeDomain> {\r\n    if (!Param.isValidEnumValue<Contract.FilterDomainType>(domainType, Contract.FilterDomainType)) {\r\n      throw new Error('Invalid value for parameter FilterDomainType');\r\n    }\r\n    const verb = VerbId.GetRangeDomain;\r\n    let parameters: ExecuteParameters = {};\r\n    parameters[ParameterId.VisualId] = {\r\n      worksheet: worksheetName\r\n    };\r\n    parameters[ParameterId.FieldId] = fieldId;\r\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\r\n    return this._dispatcher.execute(verb, parameters).then<Contract.RangeDomain>(response => {\r\n      let domain = response.result as InternalContract.RangeDomain;\r\n\r\n      return this.convertRangeDomain(domain, domainType);\r\n    });\r\n  }\r\n\r\n  // Helper Methods\r\n  private convertDomainFilters(domainFilters: InternalContract.Filter[]): Contract.Filter[] {\r\n    let filters: Contract.Filter[] = [];\r\n    domainFilters.forEach(domainFilter => {\r\n      switch (domainFilter.filterType) {\r\n        case FilterType.Categorical: {\r\n          let filter = domainFilter as InternalContract.CategoricalFilter;\r\n          if (filter) {\r\n            filters.push(this.convertCategoricalFilter(filter));\r\n          } else {\r\n            throw new Error('Invalid Categorical Filter');\r\n          }\r\n          break;\r\n        }\r\n\r\n        case FilterType.Range: {\r\n          let filter = domainFilter as InternalContract.RangeFilter;\r\n          if (filter) {\r\n            filters.push(this.convertRangeFilter(filter));\r\n          } else {\r\n            throw new Error('Invalid Range Filter');\r\n          }\r\n          break;\r\n        }\r\n\r\n        case FilterType.RelativeDate: {\r\n          let filter = domainFilter as InternalContract.RelativeDateFilter;\r\n          if (filter) {\r\n            filters.push(this.convertRelativeDateFilter(filter));\r\n          } else {\r\n            throw new Error('Invalid Relative Date Filter');\r\n          }\r\n          break;\r\n        }\r\n\r\n        default: {\r\n          break;\r\n        }\r\n      }\r\n    });\r\n    return filters;\r\n  }\r\n\r\n  private convertCategoricalFilter(domainFilter: InternalContract.CategoricalFilter): Contract.CategoricalFilter {\r\n    let appliedValues: Contract.DataValue[] = domainFilter.values.map(dv => {\r\n      return new DataValue(dv.value, dv.formattedValue);\r\n    });\r\n\r\n    return new CategoricalFilter(\r\n      domainFilter.visualId.worksheet,\r\n      domainFilter.fieldCaption,\r\n      domainFilter.fieldName,\r\n      Contract.FilterType.Categorical,\r\n      appliedValues,\r\n      domainFilter.isExclude);\r\n  }\r\n\r\n  private convertRangeFilter(domainFilter: InternalContract.RangeFilter): Contract.RangeFilter {\r\n    let minValue: DataValue = new DataValue(domainFilter.min.value, domainFilter.min.formattedValue);\r\n    let maxValue: DataValue = new DataValue(domainFilter.max.value, domainFilter.max.formattedValue);\r\n    return new RangeFilter(\r\n      domainFilter.visualId.worksheet,\r\n      domainFilter.fieldCaption,\r\n      domainFilter.fieldName,\r\n      Contract.FilterType.Range,\r\n      minValue,\r\n      maxValue,\r\n      domainFilter.includeNullValues\r\n    );\r\n  }\r\n\r\n  private convertRelativeDateFilter(domainFilter: InternalContract.RelativeDateFilter): Contract.RelativeDateFilter {\r\n    let anchorDateValue: DataValue = new DataValue(domainFilter.anchorDate.value, domainFilter.anchorDate.formattedValue);\r\n    return new RelativeDateFilter (\r\n      domainFilter.visualId.worksheet,\r\n      domainFilter.fieldCaption,\r\n      domainFilter.fieldName,\r\n      Contract.FilterType.RelativeDate,\r\n      anchorDateValue,\r\n      InternalEnumConverter.dateStepPeriod.convert(domainFilter.periodType),\r\n      InternalEnumConverter.dateRangeType.convert(domainFilter.rangeType),\r\n      domainFilter.rangeN\r\n    );\r\n  }\r\n\r\n  private convertCategoricalDomain(\r\n    domain: InternalContract.CategoricalDomain,\r\n    domainType: Contract.FilterDomainType): Contract.CategoricalDomain {\r\n    let values: DataValue[] = domain.values.map((domainDv) => {\r\n      return new DataValue(domainDv.value, domainDv.formattedValue);\r\n    });\r\n    return new CategoricalDomain(values, domainType);\r\n  }\r\n\r\n  private convertRangeDomain(domain: InternalContract.RangeDomain, domainType: Contract.FilterDomainType): Contract.RangeDomain {\r\n    let min: DataValue = new DataValue(domain.min.value, domain.min.formattedValue);\r\n    let max: DataValue = new DataValue(domain.max.value, domain.max.formattedValue);\r\n    return new RangeDomain(\r\n      min,\r\n      max,\r\n      domainType\r\n    );\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/FilterServiceImpl.ts\n **/","import {\r\n  FilterDomainType as ExternalDomainType,\r\n  FilterNullOption as ExternalNullOption\r\n} from '@tableau/api-external-contract';\r\nimport {\r\n  FilterDomainType as InternalDomainType,\r\n  FilterNullOption as InternalNullOption\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport { EnumConverter } from '@tableau/api-utils';\r\n\r\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\r\n/**\r\n * Maps enums used by the external-api-contract to the enums used\r\n * in the internal-api-contract, which developers code against.\r\n */\r\nexport class ExternalToInternalEnumMappings {\r\n  public static nullOptions = new EnumConverter<ExternalNullOption, InternalNullOption>({\r\n    [ExternalNullOption.AllValues]: InternalNullOption.AllValues,\r\n    [ExternalNullOption.NonNullValues]: InternalNullOption.NonNullValues,\r\n    [ExternalNullOption.NonNullValues]: InternalNullOption.NullValues\r\n  });\r\n\r\n  public static filterDomainType = new EnumConverter<ExternalDomainType, InternalDomainType>({\r\n    [ExternalDomainType.Relevant]: InternalDomainType.Relevant,\r\n    [ExternalDomainType.Database]: InternalDomainType.Database\r\n  });\r\n}\r\n/* tslint:enable:typedef */\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/EnumMappings/ExternalToInternalEnumMappings.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { FilterService } from '../Services/FilterService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\n\r\nexport class Filter implements Contract.Filter {\r\n  public constructor(\r\n    protected _worksheetName: string,\r\n    protected _fieldName: string,\r\n    protected _filterType: Contract.FilterType,\r\n    protected _fieldId: string) {\r\n  }\r\n\r\n  public get worksheetName(): string {\r\n    return this._worksheetName;\r\n  }\r\n\r\n  public get fieldName(): string {\r\n    return this._fieldName;\r\n  }\r\n\r\n  public get fieldId(): string {\r\n    return this._fieldId;\r\n  }\r\n\r\n  public get filterType(): Contract.FilterType {\r\n    return this._filterType;\r\n  }\r\n\r\n  public getFieldAsync(): Promise<Contract.Field> {\r\n    throw new Error('Method not implemented');\r\n  }\r\n}\r\n\r\nexport class CategoricalFilter extends Filter implements Contract.CategoricalFilter {\r\n  public constructor(\r\n    worksheetName: string,\r\n    fieldName: string,\r\n    fieldId: string,\r\n    filterType: Contract.FilterType,\r\n    private _appliedValues: Contract.DataValue[],\r\n    private _isExcludeMode: boolean) {\r\n      super(worksheetName, fieldName, filterType, fieldId);\r\n  }\r\n\r\n  public get appliedValues(): Contract.DataValue[] {\r\n    return this._appliedValues;\r\n  }\r\n\r\n  public get isExcludeMode(): boolean {\r\n    return this._isExcludeMode;\r\n  }\r\n\r\n  public getDomainAsync(domainType?: Contract.FilterDomainType): Promise<Contract.CategoricalDomain> {\r\n    if (!domainType) {\r\n      domainType = Contract.FilterDomainType.Relevant;\r\n    }\r\n    const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n    return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType);\r\n  }\r\n}\r\n\r\nexport class RangeFilter extends Filter implements Contract.RangeFilter {\r\n  public constructor(\r\n    worksheetName: string,\r\n    fieldName: string,\r\n    fieldId: string,\r\n    filterType: Contract.FilterType,\r\n    private _min: Contract.DataValue,\r\n    private _max: Contract.DataValue,\r\n    private _includeNullValues: boolean) {\r\n      super(worksheetName, fieldName, filterType, fieldId);\r\n  }\r\n\r\n  public get minValue(): Contract.DataValue {\r\n    return this._min;\r\n  }\r\n\r\n  public get maxValue(): Contract.DataValue {\r\n    return this._max;\r\n  }\r\n\r\n  public get includeNullValues(): boolean {\r\n    return this._includeNullValues;\r\n  }\r\n\r\n  public  getDomainAsync(domainType?: Contract.FilterDomainType): Promise<Contract.RangeDomain> {\r\n    const service = ApiServiceRegistry.instance.getService<FilterService>(ServiceNames.Filter);\r\n    if (!domainType) {\r\n      domainType = Contract.FilterDomainType.Relevant;\r\n    }\r\n    return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType);\r\n  }\r\n}\r\n\r\nexport class RelativeDateFilter extends Filter implements Contract.RelativeDateFilter {\r\n  public constructor(\r\n    worksheetName: string,\r\n    fieldName: string,\r\n    fieldId: string,\r\n    filterType: Contract.FilterType,\r\n    private _anchorDate: Contract.DataValue,\r\n    private _periodType: Contract.PeriodType,\r\n    private _rangeType: Contract.DateRangeType,\r\n    private _rangeN: number) {\r\n      super(worksheetName, fieldName, filterType, fieldId);\r\n  }\r\n\r\n  public get anchorDate(): Contract.DataValue {\r\n    return this._anchorDate;\r\n  }\r\n\r\n  public get periodType(): Contract.PeriodType {\r\n    return this._periodType;\r\n  }\r\n\r\n  public get rangeType(): Contract.DateRangeType {\r\n    return this._rangeType;\r\n  }\r\n\r\n  public get rangeN(): number {\r\n    return this._rangeN;\r\n  }\r\n}\r\n\r\nexport class CategoricalDomain implements Contract.CategoricalDomain {\r\n  public constructor(\r\n    private _values: Contract.DataValue[],\r\n    private _domainType: Contract.FilterDomainType) {\r\n  }\r\n\r\n  public get values(): Contract.DataValue[] {\r\n    return this._values;\r\n  }\r\n\r\n  public get type(): Contract.FilterDomainType {\r\n    return this._domainType;\r\n  }\r\n}\r\n\r\nexport class RangeDomain implements Contract.RangeDomain {\r\n  public constructor(\r\n    private _min: Contract.DataValue,\r\n    private _max: Contract.DataValue,\r\n    private _domainType: Contract.FilterDomainType) {\r\n  }\r\n\r\n  public get type(): Contract.FilterDomainType {\r\n    return this._domainType;\r\n  }\r\n\r\n  public get min(): Contract.DataValue {\r\n    return this._min;\r\n  }\r\n\r\n  public get max(): Contract.DataValue {\r\n    return this._max;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Models/FilterModels.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nexport class DataTable implements Contract.DataTable {\r\n  private _name: string;\r\n\r\n  public constructor(\r\n    private _data: Array<Array<Contract.DataValue>>,\r\n    private _columns: Array<Contract.Column>,\r\n    private _totalRowCount: number,\r\n    private _isSummaryData: boolean,\r\n    private _marksInfo?: Array<MarkInfo>) {\r\n        // TODO: get rid of this in redesign.\r\n        this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table';\r\n    }\r\n\r\n  public get name(): string {\r\n    return this._name;\r\n  }\r\n\r\n  public get data(): Array<Array<Contract.DataValue>> {\r\n    return this._data;\r\n  }\r\n\r\n  public get columns(): Array<Contract.Column> {\r\n    return this._columns;\r\n  }\r\n\r\n  public get marksInfo(): Array<Contract.MarkInfo> | undefined {\r\n    return this._marksInfo;\r\n  }\r\n\r\n  public get totalRowCount(): number {\r\n    return this._totalRowCount;\r\n  }\r\n\r\n  public get isSummaryData(): boolean {\r\n    return this._isSummaryData;\r\n  }\r\n}\r\n\r\nexport class MarkInfo implements Contract.MarkInfo {\r\n  public constructor(\r\n    private _type: Contract.MarkType,\r\n    private _color: string,\r\n    private _tupleId?: Number\r\n  ) {}\r\n\r\n  public get type(): Contract.MarkType {\r\n    return this._type;\r\n  }\r\n\r\n  public get color(): string {\r\n    return this._color;\r\n  }\r\n\r\n  public get tupleId(): Number | undefined {\r\n    return this._tupleId;\r\n  }\r\n}\r\n\r\nexport class Column implements Contract.Column {\r\n  public constructor(\r\n    private _fieldName: string,\r\n    private _dataType: Contract.DataType, // TODO: this shoudl be an enum type\r\n    private _isReferenced: boolean,\r\n    private _index: number) {}\r\n\r\n  public get fieldName(): string {\r\n    return this._fieldName;\r\n  }\r\n\r\n  public get dataType(): Contract.DataType {\r\n    return this._dataType;\r\n  }\r\n\r\n  public get isReferenced(): boolean {\r\n    return this._isReferenced;\r\n  }\r\n\r\n  public get index(): number {\r\n    return this._index;\r\n  }\r\n}\r\n\r\nexport class DataValue implements Contract.DataValue {\r\n  /* tslint:disable:no-any */\r\n  public constructor(\r\n    private _value: any,\r\n    private _formattedValue: string) {}\r\n\r\n  public get value(): any {\r\n    return this._value;\r\n  }\r\n\r\n  public get formattedValue(): string {\r\n    return this._formattedValue;\r\n  }\r\n  /* tslint:enable:no-any */\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Models/GetDataModels.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport {\r\n  DataTable as DataTableInternalContract,\r\n  ExecuteParameters,\r\n  HighlightedMarksTable,\r\n  InternalApiDispatcher,\r\n  ParameterId,\r\n  SelectedMarksTable,\r\n  UnderlyingDataTable,\r\n  VerbId,\r\n  VisualId,\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport { Column, DataTable, DataValue, MarkInfo } from '../../Models/GetDataModels';\r\nimport { GetDataService, GetDataType } from '../GetDataService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nexport class GetDataServiceImpl implements GetDataService {\r\n  private _dispatcher: InternalApiDispatcher;\r\n\r\n  public constructor(dispatcher: InternalApiDispatcher) {\r\n    this._dispatcher = dispatcher;\r\n  }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.GetData;\r\n  }\r\n\r\n  public getUnderlyingDataAsync(\r\n    visualId: VisualId,\r\n    getType: GetDataType,\r\n    ignoreAliases: boolean,\r\n    ignoreSelection: boolean,\r\n    includeAllColumns: boolean,\r\n    maxRows: number): Promise<DataTable> {\r\n      // Create all of our parameters\r\n      const verb = getType === GetDataType.Summary ? VerbId.GetDataSummaryData : VerbId.GetUnderlyingData;\r\n      const parameters: ExecuteParameters = {};\r\n      parameters[ParameterId.VisualId] = visualId;\r\n      parameters[ParameterId.IgnoreAliases] = ignoreAliases;\r\n      parameters[ParameterId.IgnoreSelection] = ignoreSelection;\r\n      parameters[ParameterId.IncludeAllColumns] = includeAllColumns;\r\n      parameters[ParameterId.MaxRows] = maxRows;\r\n\r\n      return this._dispatcher.execute(verb, parameters).then<DataTable>(response => {\r\n        const responseData = response.result as UnderlyingDataTable;\r\n        return this.processResultsTable(responseData.data, responseData.isSummary);\r\n      });\r\n    }\r\n\r\n  public getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\r\n    const parameters: ExecuteParameters = { [ParameterId.VisualId]: visualId };\r\n    return this._dispatcher.execute(VerbId.GetSelectedMarks, parameters).then<Contract.MarksCollection>(response => {\r\n      const responseData = response.result as SelectedMarksTable;\r\n      return {\r\n        data: responseData.data.map(table => this.processResultsTable(table, true))\r\n      };\r\n    });\r\n  }\r\n\r\n  public getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\r\n    const parameters: ExecuteParameters = { [ParameterId.VisualId]: visualId };\r\n    return this._dispatcher.execute(VerbId.GetHighlightedMarks, parameters).then<Contract.MarksCollection>(response => {\r\n      const responseData = response.result as HighlightedMarksTable;\r\n      return {\r\n        data: responseData.data.map(table => this.processResultsTable(table, true))\r\n      };\r\n    });\r\n  }\r\n\r\n  public getDataSourceDataAsync(\r\n    dataSourceId: string,\r\n    ignoreAliases: boolean,\r\n    maxRows: number,\r\n    columnsToInclude: Array<string>): Promise<DataTable> {\r\n      const parameters: ExecuteParameters = {\r\n        [ParameterId.DataSourceId]: dataSourceId,\r\n        [ParameterId.IgnoreAliases]: ignoreAliases,\r\n        [ParameterId.MaxRows]: maxRows,\r\n        [ParameterId.ColumnsToInclude]: columnsToInclude,\r\n      };\r\n\r\n      return this._dispatcher.execute(VerbId.GetDataSourceData, parameters).then<DataTable>(response => {\r\n        const responseData = response.result as UnderlyingDataTable;\r\n        return this.processResultsTable(responseData.data, false);\r\n      });\r\n    }\r\n\r\n  protected processResultsTable(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\r\n    const headers = responseData.headers.map(h => new Column(h.fieldCaption,\r\n                                                            Contract.DataType.String /*h.DataType*/,\r\n                                                            h.isReferenced,\r\n                                                            h.index));\r\n    // TODO This should be controlled by a flag indicating whether this api will respond marks info or not\r\n    let marks;\r\n    if (responseData.marks) {\r\n      marks = responseData.marks.map(h => new MarkInfo(h.type,\r\n                                                           h.color,\r\n                                                           h.tupleId));\r\n    }\r\n    const table = responseData.dataTable.map(row => {\r\n      return row.map(cell => {\r\n        return new DataValue(cell.value, cell.formattedValue);\r\n      });\r\n    });\r\n\r\n    if (marks) {\r\n      return new DataTable(table, headers, table.length, isSummary, marks);\r\n    }\r\n    return new DataTable(table, headers, table.length, isSummary);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/GetDataServiceImpl.ts\n **/","import { InternalApiDispatcher, Model, Notification, NotificationId } from '@tableau/api-internal-contract';\r\n\r\nimport { NotificationService, UnregisterFn } from '../NotificationService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nclass Registration {\r\n  public constructor(\r\n    private _filterFn: (notificationModel: Model) => boolean,\r\n    private _callbackFn: (notificationModel: Model) => void) {\r\n      // Nothing Here\r\n  }\r\n\r\n  public onNotification(notificationModel: Model): void {\r\n    if (this._filterFn(notificationModel)) {\r\n      this._callbackFn(notificationModel);\r\n    }\r\n  }\r\n}\r\n\r\nexport class NotificationServiceImpl implements NotificationService {\r\n  private _handlers: { [notificationId: string]: Array<Registration> };\r\n\r\n  public constructor(private dispatcher: InternalApiDispatcher) {\r\n    this._handlers = {};\r\n    this.dispatcher.registerNotificationHandler(this.onNotification.bind(this));\r\n  }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.Notification;\r\n  }\r\n\r\n  public registerHandler(id: NotificationId, filterFn: (model: Model) => boolean, handler: (model: Model) => void): UnregisterFn {\r\n    const handlers = this._handlers[id] || new Array<Registration>();\r\n    const registration = new Registration(filterFn, handler);\r\n    handlers.push(registration);\r\n    this._handlers[id] = handlers;\r\n    return () => this.removeRegistration(id, registration);\r\n  }\r\n\r\n  private hasHandlersForNotificationType(id: NotificationId): boolean {\r\n    return this._handlers.hasOwnProperty(id);\r\n  }\r\n\r\n  private onNotification(notification: Notification): void {\r\n    if (!this.hasHandlersForNotificationType(notification.notificationId)) {\r\n      return;\r\n    }\r\n\r\n    // Go through and check for all the handlers of this particular notification\r\n    this._handlers[notification.notificationId].forEach(h => h.onNotification(notification.data));\r\n  }\r\n\r\n  private removeRegistration(id: NotificationId, registration: Registration): void {\r\n    if (!this.hasHandlersForNotificationType(id)) {\r\n      return;\r\n    }\r\n\r\n    this._handlers[id] = this._handlers[id].filter(reg => reg !== registration);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/NotificationServiceImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport {\r\n  ExecuteParameters,\r\n  InternalApiDispatcher,\r\n  Model,\r\n  ParameterId,\r\n  ParameterInfo,\r\n  SheetPath,\r\n  VerbId,\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { ParameterImpl } from '../../Impl/ParameterImpl';\r\nimport { Parameter } from '../../Parameter';\r\nimport { ParametersService } from '../ParametersService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nexport class ParametersServiceImpl implements ParametersService {\r\n  public constructor(private dispatcher: InternalApiDispatcher) {\r\n  }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.Parameters;\r\n  }\r\n\r\n  public getParametersForSheetAsync(sheetPath: SheetPath, sheet: Contract.Sheet): Promise<Array<Parameter>> {\r\n    const parameters = {\r\n      [ParameterId.SheetPath]: sheetPath\r\n    };\r\n\r\n    return this.dispatcher.execute(VerbId.GetParametersForSheet, parameters).then(response => {\r\n      // TODO - Check for error\r\n\r\n      const result = response.result as Array<ParameterInfo>;\r\n      return result.map(parameterInfo => {\r\n        const impl = new ParameterImpl(parameterInfo);\r\n        return new Parameter(impl, sheet);\r\n      });\r\n    });\r\n  }\r\n\r\n  public changeParameterValueAsync(fieldName: string, newValue: string): Promise<ParameterInfo> {\r\n    const parameters = {\r\n      [ParameterId.ParameterFieldName]: fieldName,\r\n      [ParameterId.ParameterValue]: newValue\r\n    };\r\n\r\n    return this.dispatcher.execute(VerbId.ChangeParameterValue, parameters).then(response => {\r\n      const result = response.result as ParameterInfo;\r\n      return result;\r\n    });\r\n  }\r\n\r\n  public findParameterByNameAsync(name: string, sheet: Contract.Sheet): Promise<Parameter | undefined> {\r\n    return this.findParameterAsync(sheet, name, undefined);\r\n  }\r\n\r\n  public findParameterByGlobalFieldNameAsync(fieldName: string, sheet: Contract.Sheet): Promise<Parameter | undefined> {\r\n    return this.findParameterAsync(sheet, undefined, fieldName);\r\n  }\r\n\r\n  private findParameterAsync(\r\n    sheet: Contract.Sheet,\r\n    name: string | undefined,\r\n    fieldName: string | undefined): Promise<Parameter | undefined> {\r\n    const parameters: ExecuteParameters = {};\r\n    if (name !== undefined) {\r\n      parameters[ParameterId.ParameterCaption] = name;\r\n    } else if (fieldName !== undefined) {\r\n      parameters[ParameterId.ParameterFieldName] = fieldName;\r\n    } else {\r\n      throw TableauException.missingParameter(['field name or caption']);\r\n    }\r\n\r\n    return this.dispatcher.execute(VerbId.FindParameter, parameters).then(response => {\r\n      const instanceOfParameterInfo = (object: Model): object is ParameterInfo => {\r\n        return 'fieldName' in object;\r\n      };\r\n\r\n      // We need to check to see if we got a valid response back again\r\n      if (instanceOfParameterInfo(response.result)) {\r\n        const result = response.result as ParameterInfo;\r\n        const impl = new ParameterImpl(result);\r\n        return new Parameter(impl, sheet);\r\n      } else {\r\n        return undefined;\r\n      }\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/ParametersServiceImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { NotificationId, ParameterInfo } from '@tableau/api-internal-contract';\r\nimport { Param } from '@tableau/api-utils';\r\n\r\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\r\nimport { ParameterChangedEvent } from '../Events/ParameterChangedEvent';\r\nimport { DataValue } from '../Models/GetDataModels';\r\nimport { NotificationService } from '../Services/NotificationService';\r\nimport { ParametersService } from '../Services/ParametersService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\nimport { SingleEventManager } from '../SingleEventManager';\r\nimport { SingleEventManagerImpl } from './SingleEventManagerImpl';\r\n\r\nexport class ParameterImpl {\r\n  private _allowableValues: Contract.ParameterDomainRestriction;\r\n  private _globalFieldName: string;\r\n  private _parameterInfo: ParameterInfo;\r\n\r\n  public constructor(parameterInfo: ParameterInfo) {\r\n    this.setParameterInfo(parameterInfo);\r\n  }\r\n\r\n  public get name(): string {\r\n    return this._parameterInfo.name;\r\n  }\r\n\r\n  public get currentValue(): DataValue {\r\n    return new DataValue(this._parameterInfo.currentValue.value, this._parameterInfo.currentValue.formattedValue);\r\n  }\r\n\r\n  public get dataType(): Contract.DataType {\r\n    return InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType);\r\n  }\r\n\r\n  public get id(): string {\r\n    return this._globalFieldName;\r\n  }\r\n\r\n  public get allowableValues(): Contract.ParameterDomainRestriction {\r\n    return this._allowableValues;\r\n  }\r\n\r\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<DataValue> {\r\n    let coercedValue = Param.serializeParamterValue(newValue);\r\n    const parametersService = ApiServiceRegistry.instance.getService<ParametersService>(ServiceNames.Parameters);\r\n    return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then(parameterInfo => {\r\n      this.setParameterInfo(parameterInfo);\r\n      return this.currentValue;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Helper method which goes through and registers each event type this impl knows about\r\n   * with the NotificationService. It returns an array of SingleEventManager objects which\r\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\r\n   *\r\n   * @param sheet The sheet object which will be included with the event notifications\r\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\r\n   */\r\n  public initializeEvents(sheet: Contract.Sheet): Array<SingleEventManager> {\r\n    const results = new Array<SingleEventManager>();\r\n    let notificationService: NotificationService;\r\n\r\n    try {\r\n      notificationService = ApiServiceRegistry.instance.getService<NotificationService>(ServiceNames.Notification);\r\n    } catch (e) {\r\n      // If we don't have this service registered, just return\r\n      return results;\r\n    }\r\n\r\n    // Initialize all of the event managers we'll need (one for each event type)\r\n    const parameterEvent = new SingleEventManagerImpl<ParameterChangedEvent>(Contract.TableauEventType.ParameterChanged);\r\n    notificationService.registerHandler(NotificationId.ParameterChanged, (model) => {\r\n      const fieldName = model as string;\r\n      return fieldName === this._globalFieldName;\r\n    }, (fieldName: string) => {\r\n      parameterEvent.triggerEvent(() => new ParameterChangedEvent(fieldName, sheet));\r\n    });\r\n\r\n    results.push(parameterEvent);\r\n\r\n    return results;\r\n  }\r\n\r\n  private setParameterInfo(parameterInfo: ParameterInfo): void {\r\n    this._parameterInfo = parameterInfo;\r\n    this._globalFieldName = parameterInfo.fieldName;\r\n\r\n    const type = InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType);\r\n    let listValues: Array<DataValue> | undefined;\r\n    let minValue: DataValue | undefined;\r\n    let maxValue: DataValue | undefined;\r\n    let stepSize: number | undefined;\r\n    let dateStepPeriod: Contract.PeriodType | undefined;\r\n\r\n    if (type === Contract.ParameterValueType.List) {\r\n      const values = parameterInfo.allowableValues || [];\r\n      listValues = values.map(val => new DataValue(val.value, val.formattedValue));\r\n    } else if (type === Contract.ParameterValueType.Range) {\r\n      minValue = parameterInfo.minValue && new DataValue(parameterInfo.minValue.value, parameterInfo.minValue.formattedValue);\r\n      maxValue = parameterInfo.maxValue && new DataValue(parameterInfo.maxValue.value, parameterInfo.maxValue.formattedValue);\r\n      stepSize = parameterInfo.stepSize;\r\n      dateStepPeriod = parameterInfo.dateStepPeriod &&\r\n                       InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod);\r\n    }\r\n\r\n    this._allowableValues = {\r\n      type: type,\r\n      allowableValues: listValues,\r\n      minValue: minValue,\r\n      maxValue: maxValue,\r\n      stepSize: stepSize,\r\n      dateStepPeriod: dateStepPeriod\r\n    };\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Impl/ParameterImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\nimport { ParametersService } from '../Services/ParametersService';\r\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\r\nimport { TableauSheetEvent } from './TableauSheetEvent';\r\n\r\nexport class ParameterChangedEvent extends TableauSheetEvent implements Contract.ParameterChangedEvent {\r\n  private static PARAM_NOT_FOUND: string = 'Unable to find parameter';\r\n  public constructor(private _globalFieldName: string, sheet: Contract.Sheet) {\r\n    super(Contract.TableauEventType.ParameterChanged, sheet);\r\n  }\r\n\r\n  public getParameterAsync(): Promise<Contract.Parameter> {\r\n    // Call down to our service to get the parameter back via its field name\r\n    const service = ApiServiceRegistry.instance.getService<ParametersService>(ServiceNames.Parameters);\r\n    return service.findParameterByGlobalFieldNameAsync(this._globalFieldName, this.sheet).then(parameter => {\r\n      if (parameter === undefined) {\r\n        throw TableauException.error(ParameterChangedEvent.PARAM_NOT_FOUND);\r\n      }\r\n\r\n      return parameter;\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Events/ParameterChangedEvent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { EventListenerManager } from './EventListenerManager';\r\nimport { ParameterImpl } from './Impl/ParameterImpl';\r\n\r\n/**\r\n * Implementation of the Parameter contract. Calls down to the impl\r\n * class for almost all of the work it does.\r\n */\r\nexport class Parameter extends EventListenerManager implements Contract.Parameter {\r\n  public constructor(private parameterImpl: ParameterImpl, sheet: Contract.Sheet) {\r\n    super();\r\n\r\n    // Initialize our event handling for this class\r\n    this.parameterImpl.initializeEvents(sheet).forEach(e => this.addNewEventType(e));\r\n  }\r\n\r\n  public get name(): string {\r\n    return this.parameterImpl.name;\r\n  }\r\n\r\n  public get currentValue(): Contract.DataValue {\r\n    return this.parameterImpl.currentValue;\r\n  }\r\n\r\n  public get dataType(): Contract.DataType {\r\n    return this.parameterImpl.dataType;\r\n  }\r\n\r\n  public get allowableValues(): Contract.ParameterDomainRestriction {\r\n    return this.parameterImpl.allowableValues;\r\n  }\r\n\r\n  public get id(): string {\r\n    return this.parameterImpl.id;\r\n  }\r\n\r\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<Contract.DataValue> {\r\n    return this.parameterImpl.changeValueAsync(newValue);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Parameter.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\nimport {\r\n  ExecuteParameters,\r\n  InternalApiDispatcher,\r\n  ParameterId,\r\n  QuantitativeIncludedValues,\r\n  SelectionUpdateType as SelectionUpdateTypeInternal,\r\n  VerbId,\r\n  VisualId\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\nimport { DimensionSelectionModel,\r\n  HierarchicalSelectionModel,\r\n  RangeSelectionModel,\r\n  SelectionModelsContainer,\r\n  TupleSelectionModel,\r\n  ValueSelectionModel\r\n} from '../../Models/SelectionModels';\r\nimport { SelectionService } from '../SelectionService';\r\nimport { ServiceNames } from '../ServiceRegistry';\r\n\r\nexport class SelectionServiceImpl implements SelectionService {\r\n  private _dispatcher: InternalApiDispatcher;\r\n\r\n  public constructor(dispatcher: InternalApiDispatcher) {\r\n    this._dispatcher = dispatcher;\r\n  }\r\n\r\n  public get serviceName(): string {\r\n    return ServiceNames.Selection;\r\n  }\r\n\r\n  /**\r\n   * Method to clear all the selected marks for the given worksheet.\r\n   *\r\n   * @param visualId\r\n   */\r\n  public clearSelectedMarksAsync(visualId: VisualId): Promise<void> {\r\n    const parameters: ExecuteParameters = {[ParameterId.VisualId]: visualId};\r\n    return this._dispatcher.execute(VerbId.ClearSelectedMarks, parameters).then<void>(response => {\r\n      return ; // Expecting an empty model and hence the void response.\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Method to select marks for the given worksheet.\r\n   *\r\n   * @param visualId\r\n   * @param selectionCriteria\r\n   * @param selectionUpdateType\r\n   */\r\n  public selectMarksByValueAsync(visualId: VisualId,\r\n                                 selectionCriterias: Array<Contract.SelectionCriteria>,\r\n                                 selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    if (selectionCriterias.length === 0) {\r\n      throw TableauException.invalid(['Selection criteria', 'Selections missing.']);\r\n    }\r\n\r\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\r\n    let selectionCriteriaType: SelectionCriteriaType = this.validateSelectionCriteria(selectionCriterias[0]);\r\n    let selectionModelContainer: SelectionModelsContainer = this.parseSelectionMarks(selectionCriterias, selectionCriteriaType);\r\n\r\n    const parameters: ExecuteParameters = {\r\n      [ParameterId.VisualId]: visualId,\r\n      [ParameterId.SelectionUpdateType]: selectionType\r\n    };\r\n\r\n    switch (selectionCriteriaType) {\r\n      case SelectionCriteriaType.HierarchicalType: {\r\n        parameters[ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr;\r\n        break;\r\n      }\r\n      case SelectionCriteriaType.RangeType: {\r\n        parameters[ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr;\r\n        break;\r\n      }\r\n      case SelectionCriteriaType.DimensionType: {\r\n        parameters[ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr;\r\n        break;\r\n      }\r\n      default:\r\n        break;\r\n    }\r\n    return this._dispatcher.execute(VerbId.SelectByValue, parameters).then<void>(response => {\r\n      // Expecting an empty model and hence the void response.\r\n      return;\r\n      // TODO Investigate the error response with multiple output params and throw error accordingly.\r\n    });\r\n  }\r\n\r\n    /**\r\n   * Method to select marks for the given worksheet.\r\n   *\r\n   * @param visualId\r\n   * @param MarkInfo\r\n   * @param selectionUpdateType\r\n   */\r\n  public selectMarksByIdAsync(visualId: VisualId,\r\n                              marks: Array<Contract.MarkInfo>,\r\n                              selectionUpdateType: Contract.SelectionUpdateType): Promise<void> {\r\n    if (marks.length === 0) {\r\n      throw TableauException.invalid(['Selection', 'Marks info missing.']);\r\n    }\r\n\r\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\r\n    let selectionModelContainer: SelectionModelsContainer = this.parseSelectionIds(marks);\r\n\r\n    const parameters: ExecuteParameters = {\r\n      [ParameterId.VisualId]: visualId,\r\n      [ParameterId.SelectionUpdateType]: selectionType,\r\n      [ParameterId.Selection]: selectionModelContainer.selection\r\n    };\r\n    return this._dispatcher.execute(VerbId.SelectByValue, parameters).then<void>(response => {\r\n      // Expecting an empty model and hence the void response.\r\n      return;\r\n      // TODO Investigate the error response with multiple output params and throw error accordingly.\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Method to prepare the pres models for selection by MarksInfo\r\n   * @param marks\r\n   */\r\n  private parseSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\r\n    let ids: Array<string> = [];\r\n    let selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\r\n    for (let i = 0; i < marks.length; i++) {\r\n      let tupleId: Number | undefined  = marks[i].tupleId;\r\n      if (tupleId !== undefined && tupleId !== null) { // If tuple id is provided use that instead of pair\r\n         ids.push(tupleId.toString()); // collect the tuple ids\r\n      } else {\r\n        throw TableauException.invalid(['tupleId']);\r\n      }\r\n    }\r\n    if (ids.length !== 0) { // tuple ids based selection\r\n      let tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\r\n      tupleSelectionModel.selectionType = 'tuples';\r\n      tupleSelectionModel.objectIds = ids;\r\n      selectionModelContainer.selection = tupleSelectionModel;\r\n    }\r\n    return selectionModelContainer;\r\n  }\r\n  /**\r\n   * Method to prepare the pres models for selection by values.\r\n   *\r\n   * Supports 3 types for selection:\r\n   * 1) hierarchical value based selection\r\n   * 2) range value based selection\r\n   * 3) Dimension value based selection\r\n   *\r\n   * @param marks\r\n   * @param hierModelArr\r\n   * @param dimModelArr\r\n   * @param quantModelArr\r\n   * @param selection\r\n   */\r\n  private parseSelectionMarks(selectionCriterias: Array<Contract.SelectionCriteria>,\r\n                              selectionType: SelectionCriteriaType): SelectionModelsContainer {\r\n    let selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\r\n    let mixedSelectionsError: boolean = false;\r\n\r\n    for (let i = 0; i < selectionCriterias.length; i++) {\r\n      const st = selectionCriterias[i];\r\n      if (st.fieldName && (st.value !== undefined && st.value !== null)) {\r\n        let catRegex = new RegExp('(\\[[A-Za-z0-9]+]).*', 'g');\r\n        let rangeOption: Contract.RangeValue = st.value as Contract.RangeValue;\r\n        if (catRegex.test(st.fieldName)) { // Hierarchical value selection\r\n          if (selectionType === SelectionCriteriaType.HierarchicalType) {\r\n            let hierModel: HierarchicalSelectionModel = <HierarchicalSelectionModel> this.addToParamsList(st.fieldName, st.value);\r\n            selectionModelContainer.hierModelArr.push(hierModel);\r\n          } else {\r\n            mixedSelectionsError = true;\r\n            break;\r\n          }\r\n        } else if ((<Contract.RangeValue> rangeOption).min !== undefined\r\n                && (<Contract.RangeValue> rangeOption).max !== undefined) { // Range value selection\r\n          if (selectionType === SelectionCriteriaType.RangeType) {\r\n            let quantModel: RangeSelectionModel = this.addToRangeParamsList(st.fieldName, rangeOption);\r\n            selectionModelContainer.quantModelArr.push(quantModel);\r\n          } else {\r\n            mixedSelectionsError = true;\r\n            break;\r\n          }\r\n        } else { // Dimension value selection\r\n          if (selectionType === SelectionCriteriaType.DimensionType) {\r\n            let dimModel: DimensionSelectionModel = <DimensionSelectionModel> this.addToParamsList(st.fieldName, st.value);\r\n            selectionModelContainer.dimModelArr.push(dimModel);\r\n          } else {\r\n            mixedSelectionsError = true;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (mixedSelectionsError) {\r\n      throw TableauException.invalid(['Selection Criteria', 'Different types of selection criterias provided.']);\r\n    }\r\n    return selectionModelContainer;\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param selectionCriterias Validate and determine the selection criterias type.\r\n   */\r\n  private validateSelectionCriteria(selectionCriteria: Contract.SelectionCriteria): SelectionCriteriaType {\r\n    let selectionType: SelectionCriteriaType;\r\n    // Determine the type of selection, this command is by looking at the first selection\r\n    let crit: Contract.SelectionCriteria = selectionCriteria;\r\n\r\n    let catRegex = new RegExp('(\\[[A-Za-z0-9]+]).*', 'g');\r\n    let rangeOption: Contract.RangeValue = crit.value as Contract.RangeValue;\r\n\r\n    if (crit.fieldName && (crit.value !== undefined && crit.value !== null)) {\r\n      if (catRegex.test(crit.fieldName)) { // Hierarchical value selection\r\n        selectionType = SelectionCriteriaType.HierarchicalType;\r\n      } else if ((<Contract.RangeValue> rangeOption).min !== undefined\r\n                && (<Contract.RangeValue> rangeOption).max !== undefined) { // Range value selection\r\n        selectionType = SelectionCriteriaType.RangeType;\r\n      } else { // Dimersion value selection\r\n        selectionType = SelectionCriteriaType.DimensionType;\r\n      }\r\n    } else {\r\n      throw TableauException.invalid(['Selection', 'Criteria format.']);\r\n    }\r\n    return selectionType;\r\n  }\r\n\r\n  /**\r\n   * Method to transform the key value pair into value based pres model object.\r\n   *\r\n   * @param valueSelectionModel\r\n   * @param fieldName\r\n   * @param value\r\n   */\r\n  private addToParamsList(fieldName: string, value: object): ValueSelectionModel {\r\n    let valueSelectionModel: ValueSelectionModel = new ValueSelectionModel();\r\n    let markValues: Array<string> = [];\r\n\r\n    if (value instanceof Array) {\r\n      let valueArr: Array<string> = value;\r\n      for ( let i = 0; i < valueArr.length; i++) {\r\n        markValues.push(valueArr[i].toString());\r\n      }\r\n    } else {\r\n      markValues.push(value.toString());\r\n    }\r\n\r\n    valueSelectionModel.qualifiedFieldCaption = fieldName;\r\n    valueSelectionModel.selectValues = markValues;\r\n    return valueSelectionModel;\r\n  }\r\n\r\n  /**\r\n   * Method to transform the key value pair into range based selection pres model.\r\n   *\r\n   * TODO: Need to handle the parsing of date type values.\r\n   *\r\n   * @param valueSelectionModel\r\n   * @param fieldName\r\n   * @param value\r\n   */\r\n  private addToRangeParamsList(fieldName: string, value: Contract.RangeValue): RangeSelectionModel {\r\n    let rangeSelectionModel: RangeSelectionModel = new RangeSelectionModel();\r\n    rangeSelectionModel.qualifiedFieldCaption = fieldName;\r\n    if (value.max !== undefined && value.max !== null) {\r\n      rangeSelectionModel.maxValue = value.max.toString();\r\n    }\r\n    if (value.min !== undefined && value.min !== null) {\r\n      rangeSelectionModel.minValue = value.min.toString();\r\n    }\r\n    rangeSelectionModel.included = this.validateNullOptionType(value.nullOption);\r\n    return rangeSelectionModel;\r\n  }\r\n\r\n  /**\r\n   * Method to validate the selection update type.\r\n   *\r\n   * @param selectionUpdateType\r\n   */\r\n  private validateSelectionUpdateType(selectionUpdateType: Contract.SelectionUpdateType): string {\r\n    if (selectionUpdateType === Contract.SelectionUpdateType.Replace) {\r\n      return SelectionUpdateTypeInternal.Replace;\r\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Add) {\r\n      return SelectionUpdateTypeInternal.Add;\r\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) {\r\n      return SelectionUpdateTypeInternal.Remove;\r\n    }\r\n    return SelectionUpdateTypeInternal.Replace;\r\n  }\r\n\r\n  /**\r\n   * Method to validate the include type for range selection.\r\n   *\r\n   * @param nullOption\r\n   */\r\n  private validateNullOptionType(nullOption: Contract.FilterNullOption | undefined): string {\r\n    if (nullOption) {\r\n      if (nullOption === Contract.FilterNullOption.NullValues) {\r\n        return QuantitativeIncludedValues.IncludeNull;\r\n      } else if (nullOption === Contract.FilterNullOption.NonNullValues) {\r\n        return QuantitativeIncludedValues.IncludeNonNull;\r\n      } else if (nullOption === Contract.FilterNullOption.AllValues) {\r\n        return QuantitativeIncludedValues.IncludeAll;\r\n      }\r\n    }\r\n\r\n    return QuantitativeIncludedValues.IncludeAll;\r\n  }\r\n\r\n}\r\n\r\n/**\r\n * Enum for the different selection criteria types.\r\n */\r\nenum SelectionCriteriaType {\r\n  HierarchicalType = 1,\r\n  RangeType = 2,\r\n  DimensionType = 3,\r\n  TuplesType = 4,\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Services/impl/SelectionServiceImpl.ts\n **/","/**\r\n * Selection Model.\r\n */\r\nexport class SelectionModel {\r\n  qualifiedFieldCaption: string;\r\n}\r\n\r\n/**\r\n * Value based selection model. Meant for hierarchical, range and categorical selections.\r\n */\r\nexport class ValueSelectionModel extends SelectionModel {\r\n  selectValues: Array<string> = [];\r\n}\r\n\r\n/**\r\n * Hierarchical value selection model\r\n */\r\nexport class HierarchicalSelectionModel extends ValueSelectionModel {\r\n}\r\n\r\n/**\r\n * Range based value selection model\r\n */\r\nexport class RangeSelectionModel extends SelectionModel {\r\n  minValue: string;\r\n  maxValue: string;\r\n  included: string;\r\n}\r\n\r\n/**\r\n * Dimension value selection model\r\n */\r\nexport class DimensionSelectionModel extends ValueSelectionModel {\r\n}\r\n/**\r\n * Tuple based selection model\r\n */\r\nexport class TupleSelectionModel {\r\n  selectionType: string;\r\n  objectIds: Array<string> = [];\r\n}\r\n\r\n/**\r\n * Container class to populate all the selection models when parsing input\r\n */\r\nexport class SelectionModelsContainer {\r\n  hierModelArr: Array<HierarchicalSelectionModel> = [];\r\n  dimModelArr: Array<DimensionSelectionModel> = [];\r\n  quantModelArr: Array<RangeSelectionModel> = [];\r\n  selection: TupleSelectionModel;\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/Models/SelectionModels.ts\n **/","import * as Contract from '@tableau/api-internal-contract';\r\nimport {\r\n  CommandResponseMessage,\r\n  CrossFrameMessenger,\r\n  VERSION as ApiMessagingVersion,\r\n} from '@tableau/api-messaging';\r\n\r\nimport { CrossFrameDispatcher } from './CrossFrameDispatcher';\r\n\r\n// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153\r\nfunction inIframe(thisWindow: Window): boolean {\r\n  try {\r\n    return thisWindow.self !== thisWindow.parent;\r\n  } catch (e) {\r\n    return true;\r\n  }\r\n}\r\n\r\n/**\r\n * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running\r\n *\r\n * @param thisWindow The window which we are running in (injected for unit testing purposes)\r\n * @param versionNumber The version number of our API to include in the initialization message\r\n * @returns A promise which is doing the actual bootstrapping\r\n */\r\nexport function doCrossFrameBootstrap(thisWindow: Window, versionNumber: Contract.VersionNumber): Promise<Contract.InternalApiDispatcher> {\r\n  return new Promise<Contract.InternalApiDispatcher>((resolve, reject) => {\r\n\r\n    // Check to make sure we're in an iframe and have a parent to communicate with\r\n    if (!inIframe(thisWindow)) {\r\n      reject('This extension is not running inside an iframe or desktop. Initialization failed.');\r\n    }\r\n\r\n    // Create the messenger which will do he communication between this window and our parent\r\n    // Since we don't know where we are running yet, we have to make this initial origin '*'. Once\r\n    // we have successfully initialized our extension, we will limit where we send messages\r\n    const messenger = new CrossFrameMessenger(thisWindow, thisWindow.parent, '*');\r\n\r\n    // Prepare to send an initialization message to the parent frame\r\n    const initializationMessage = messenger.prepareInitializationMessage(versionNumber, ApiMessagingVersion);\r\n\r\n    // When we receive a response back from the parent, we check to make sure the guids match and then we know\r\n    // that the parent is aware of us and we can start communicating\r\n    messenger.setCommandResponseMessageHandler(function(msg: CommandResponseMessage): void {\r\n\r\n      // Verify we are getting a response from our initialize message\r\n      if (msg.commandGuid === initializationMessage.messageGuid) {\r\n        const dispatcher = new CrossFrameDispatcher(messenger);\r\n        resolve(dispatcher);\r\n      }\r\n    });\r\n\r\n    // Now that our handlers are ready, start listening and send our initialization message\r\n    messenger.startListening();\r\n    initializationMessage.send();\r\n  });\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/CrossFrame/CrossFrameBootstrap.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport * from './CrossFrameMessenger';\r\nexport * from './interface/MessageDispatcher';\r\nexport * from './interface/MessageListener';\r\nexport * from './interface/MessageTypes';\r\nexport * from './interface/Messenger';\r\nexport * from './interface/PreparedMessage';\r\n\r\n// Export the version number of messaging for consumers to use.\r\n// Be very careful making any updates to this contract which break version compatibility.\r\nexport const VERSION = {\r\n  major: 1,\r\n  minor: 0,\r\n  fix: 0\r\n};\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-messaging/src/ApiMessaging.ts\n **/","import { ExecuteParameters, Model, NotificationId, VerbId, VersionNumber } from '@tableau/api-internal-contract';\r\nimport { Guid } from '@tableau/guid';\r\n\r\nimport { CrossFramePreparedMessage } from './CrossFramePreparedMessage';\r\nimport {\r\n  CommandMessage,\r\n  CommandResponseMessage,\r\n  InitializeMessage,\r\n  Message,\r\n  MessageType,\r\n  NotificationMessage,\r\n} from './interface/MessageTypes';\r\nimport { Messenger } from './interface/Messenger';\r\nimport { PreparedMessage } from './interface/PreparedMessage';\r\nimport {\r\n  isCommandMessage,\r\n  isCommandResponseMessage,\r\n  isInitMessage,\r\n  isMessage,\r\n  isNotificationMessage,\r\n} from './MessageTypeChecks';\r\n\r\n/**\r\n * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of\r\n * this class can be instantiated on both sides of a frame boundary to facilitate communication\r\n * in both directions between the frames. This class implements both the dispatcher and the listener\r\n * portions, but doesn't require callers to care about both.\r\n */\r\nexport class CrossFrameMessenger implements Messenger {\r\n  private unregisterFunction: undefined | (() => void);\r\n  private initializeMessageHandler: undefined | ((msg: InitializeMessage, source: Window) => void);\r\n  private commandResponseMessageHandler: undefined | ((msg: CommandResponseMessage, source: Window) => void);\r\n  private commandMessageHandler: undefined | ((msg: CommandMessage, source: Window) => void);\r\n  private notificationMessageHandler: undefined | ((msg: NotificationMessage, source: Window) => void);\r\n\r\n  /**\r\n   * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener,\r\n   * be sure to call StartListening and register message handlers.\r\n   * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here.\r\n   * @param [otherWindow] Optional otherWindow which messages will be posted to.\r\n   *                      If defined, incoming messages must originate from otherWindow to be passed on\r\n   * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages.\r\n   *                            This value will be sent as the targetOrigin of a postMessage\r\n   *                            (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)\r\n   */\r\n  public constructor(private thisWindow: Window, private otherWindow?: Window, private otherWindowOrigin?: string) {\r\n    // Make sure to call StartListening\r\n  }\r\n\r\n  ///// MessageListener Implementation\r\n\r\n  public startListening(): void {\r\n    // Check if we already are listening, if not, hook up a message listener\r\n    if (!this.unregisterFunction) {\r\n      const boundHandler = this.onMessageReceived.bind(this);\r\n      this.thisWindow.addEventListener('message', boundHandler, true);\r\n      this.unregisterFunction = () => this.thisWindow.removeEventListener('message', boundHandler, true);\r\n    }\r\n  }\r\n\r\n  public stopListening(): void {\r\n    // Stop listening if we have started listening\r\n    if (this.unregisterFunction) {\r\n      this.unregisterFunction();\r\n      this.unregisterFunction = undefined;\r\n    }\r\n  }\r\n\r\n  public setInitializeMessageHandler(handler?: (msg: InitializeMessage, source: Window) => void): void {\r\n    this.initializeMessageHandler = handler;\r\n  }\r\n\r\n  public setCommandResponseMessageHandler(handler?: (msg: CommandResponseMessage, source: Window) => void): void {\r\n    this.commandResponseMessageHandler = handler;\r\n  }\r\n\r\n  public setCommandMessageHandler(handler?: (msg: CommandMessage, source: Window) => void): void {\r\n    this.commandMessageHandler = handler;\r\n  }\r\n\r\n  public setNotificationMessageHandler(handler?: (msg: NotificationMessage, source: Window) => void): void {\r\n    this.notificationMessageHandler = handler;\r\n  }\r\n\r\n  ///// MessageDispatcher Implementation\r\n\r\n  public prepareInitializationMessage(apiVersion: VersionNumber, crossFrameVersion: VersionNumber): PreparedMessage {\r\n    const message: InitializeMessage = {\r\n      msgGuid: Guid.create().formattedValue,\r\n      msgType: MessageType.Initialize,\r\n      crossFrameVersion: crossFrameVersion,\r\n      apiVersion: apiVersion\r\n    };\r\n\r\n    return this.prepareMessage(message);\r\n  }\r\n\r\n  public prepareCommandMessage(verbId: VerbId, parameters: ExecuteParameters): PreparedMessage {\r\n    const message: CommandMessage = {\r\n      msgGuid: Guid.create().formattedValue,\r\n      msgType: MessageType.Command,\r\n      verbId: verbId,\r\n      parameters: parameters\r\n    };\r\n\r\n    return this.prepareMessage(message);\r\n  }\r\n\r\n  public prepareCommandResponseMessage(commandGuid: string, data: Model | undefined, error: Model | undefined): PreparedMessage {\r\n    const message: CommandResponseMessage = {\r\n      msgGuid: Guid.create().formattedValue,\r\n      msgType: MessageType.CommandResponse,\r\n      commandGuid: commandGuid,\r\n      data: data,\r\n      error: error\r\n    };\r\n\r\n    return this.prepareMessage(message);\r\n  }\r\n\r\n  public prepareNotificationMessage(notificationId: NotificationId, data: Model): PreparedMessage {\r\n    const message: NotificationMessage = {\r\n      msgGuid: Guid.create().formattedValue,\r\n      msgType: MessageType.Notification,\r\n      notificationId: notificationId,\r\n      data: data\r\n    };\r\n\r\n    return this.prepareMessage(message);\r\n  }\r\n\r\n  /**\r\n   * Prepares a pending message for sending and returns the prepared message\r\n   *\r\n   * @param msg The message to be sent to this.otherWindow\r\n   * @returns The prepared message\r\n   */\r\n  private prepareMessage(msg: Message): PreparedMessage {\r\n    if (!this.otherWindow || !this.otherWindowOrigin) {\r\n      throw 'Other window not initialized, cannot dispatch messages';\r\n    }\r\n\r\n    const preparedMessage = new CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin);\r\n    return preparedMessage;\r\n  }\r\n\r\n  /**\r\n   * Called when a message is received. Does some validation of the message, and then\r\n   * calls an appropriate message handler if one is defined\r\n   *\r\n   * @param event The incoming MessageEvent\r\n   */\r\n  private onMessageReceived(event: MessageEvent): void {\r\n\r\n    // If we have an otherWindow defined, make sure the message is coming from there\r\n    if (this.otherWindow && event.source !== this.otherWindow) {\r\n      return;\r\n    }\r\n\r\n    // Do some validation on event.data to make sure that we have received a real message\r\n    if (!event.data) {\r\n      return;\r\n    }\r\n\r\n    const message = event.data;\r\n    if (!isMessage(message)) {\r\n      return;\r\n    }\r\n\r\n    // Check the declared message type, validate the message, and call an appropriate hander if one exists\r\n    switch (message.msgType) {\r\n      case MessageType.Initialize: {\r\n        if (!isInitMessage(message) || !this.initializeMessageHandler) {\r\n          return;\r\n        }\r\n\r\n        this.initializeMessageHandler(message, event.source);\r\n        break;\r\n      }\r\n      case MessageType.CommandResponse: {\r\n        if (!isCommandResponseMessage(message) || !this.commandResponseMessageHandler) {\r\n          return;\r\n        }\r\n\r\n        this.commandResponseMessageHandler(message, event.source);\r\n        break;\r\n      }\r\n      case MessageType.Command: {\r\n        if (!isCommandMessage(message) || !this.commandMessageHandler) {\r\n          return;\r\n        }\r\n\r\n        this.commandMessageHandler(message, event.source);\r\n        break;\r\n      }\r\n      case MessageType.Notification: {\r\n        if (!isNotificationMessage(message) || !this.notificationMessageHandler) {\r\n          return;\r\n        }\r\n\r\n        this.notificationMessageHandler(message, event.source);\r\n        break;\r\n      }\r\n      default:\r\n        // Just ignore this since we don't know how to handle the message type\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-messaging/src/CrossFrameMessenger.ts\n **/","null\n\n\n/** WEBPACK FOOTER **\n ** ../src/Guid.ts\n **/","import { Message } from './interface/MessageTypes';\r\nimport { PreparedMessage } from './interface/PreparedMessage';\r\n\r\n/**\r\n * Implementation of the PreparedMessage interface used to post messages between\r\n * two frames using window.postMessage\r\n */\r\nexport class CrossFramePreparedMessage implements PreparedMessage {\r\n  /**\r\n   * Creates an instance of CrossFramePreparedMessage.\r\n   * @param _message The message to be sent\r\n   * @param _target The target window where the message will be sent\r\n   * @param _origin The targetOrigin where this message can be received\r\n   */\r\n  public constructor(private _message: Message, private _target: Window, private _origin: string) {\r\n\r\n  }\r\n\r\n  public get messageGuid(): string { return this._message.msgGuid; }\r\n\r\n  public send(): PreparedMessage {\r\n    this._target.postMessage(this._message, this._origin);\r\n    return this;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-messaging/src/CrossFramePreparedMessage.ts\n **/","import { ExecuteParameters, Model, NotificationId, VerbId, VersionNumber } from '@tableau/api-internal-contract';\r\n\r\n/**\r\n * Enum defining the 4 different types of messages we have defined\r\n */\r\nexport enum MessageType {\r\n  Initialize = 'initialize',\r\n  Notification = 'notification',\r\n  Command = 'command',\r\n  CommandResponse = 'command-response'\r\n}\r\n\r\n/**\r\n * The Message interface is the base interface for all the other\r\n * message type interfaces.\r\n */\r\nexport interface Message {\r\n  /**\r\n   * A unique id for this message\r\n   */\r\n  msgGuid: string;\r\n\r\n  /**\r\n   * The type of this message\r\n   */\r\n  msgType: MessageType;\r\n}\r\n\r\n/**\r\n * The initialize message is the first message which will be sent\r\n * from the javascript to set up communications\r\n */\r\nexport interface InitializeMessage extends Message {\r\n  /**\r\n   * The version of the api which the sender wants to use\r\n   */\r\n  apiVersion: VersionNumber;\r\n\r\n  /**\r\n   * The version of this messaging contract to be used. For now, there\r\n   * should only be a single version but sending this along should help\r\n   * if we need to add a new version in a future release\r\n   */\r\n  crossFrameVersion: VersionNumber;\r\n}\r\n\r\n/**\r\n * This message is sent when a notification occurs from the preslayer\r\n */\r\nexport interface NotificationMessage extends Message {\r\n  /**\r\n   * The id for this type of notification\r\n   */\r\n  notificationId: NotificationId;\r\n\r\n  /**\r\n   * The data which came along with the notification\r\n   */\r\n  data: Model;\r\n}\r\n\r\n/**\r\n * Represents calling an internal contract command\r\n */\r\nexport interface CommandMessage extends Message {\r\n  /**\r\n   * The id of the command which should be executed\r\n   */\r\n  verbId: VerbId;\r\n\r\n  /**\r\n   * An object containing the parameters for the command\r\n   */\r\n  parameters: ExecuteParameters;\r\n}\r\n\r\n/**\r\n * This message is sent in response to a CommandMessage with the\r\n * result of that commands invocation\r\n */\r\nexport interface CommandResponseMessage extends Message {\r\n  /**\r\n   * Guid of the CommandMessage which this is in response to\r\n   */\r\n  commandGuid: string;\r\n\r\n  /**\r\n   * If there was an error returned from the command, this will be defined\r\n   * and contain the error\r\n   */\r\n  error?: Model;\r\n\r\n  /**\r\n   * If the command executed successfully, this will contain the command result\r\n   */\r\n  data?: Model;\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-messaging/src/interface/MessageTypes.ts\n **/","import { VersionNumber } from '@tableau/api-internal-contract';\r\nimport { Guid } from '@tableau/guid';\r\n\r\nimport {\r\n  CommandMessage,\r\n  CommandResponseMessage,\r\n  InitializeMessage,\r\n  Message,\r\n  MessageType,\r\n  NotificationMessage,\r\n} from './interface/MessageTypes';\r\n\r\n/* tslint:disable no-any */\r\nexport function isMessage(data: Message | any): data is Message {\r\n  if (!data) {\r\n    return false;\r\n  }\r\n\r\n  const message = data as Message;\r\n  if (!message || !message.msgGuid || !message.msgType) {\r\n    return false;\r\n  }\r\n\r\n  if (!Guid.isGuid(message.msgGuid)) {\r\n    return false;\r\n  }\r\n\r\n  if (typeof message.msgType !== 'string') {\r\n    return false;\r\n  }\r\n\r\n  const messageTypes: Array<string> =\r\n  [ MessageType.Command, MessageType.CommandResponse, MessageType.Initialize, MessageType.Notification ];\r\n\r\n  if (messageTypes.indexOf(message.msgType) < 0) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport function isVersion(versionNumber: VersionNumber | any): versionNumber is VersionNumber {\r\n  if (!versionNumber) {\r\n    return false;\r\n  }\r\n\r\n  const v = versionNumber as VersionNumber;\r\n\r\n  if (typeof v !== 'object') {\r\n    return false;\r\n  }\r\n\r\n  if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport function isInitMessage(message: InitializeMessage | any): message is InitializeMessage {\r\n  if (!isMessage(message)) {\r\n    return false;\r\n  }\r\n\r\n  const initMessage = message as InitializeMessage;\r\n  if (initMessage.msgType !== MessageType.Initialize) {\r\n    return false;\r\n  }\r\n\r\n  if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) {\r\n    return false;\r\n  }\r\n\r\n  if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport function isCommandResponseMessage(message: CommandResponseMessage | any): message is CommandResponseMessage {\r\n  if (!isMessage(message)) {\r\n    return false;\r\n  }\r\n\r\n  const crMessage = message as CommandResponseMessage;\r\n  if (crMessage.msgType !== MessageType.CommandResponse) {\r\n    return false;\r\n  }\r\n\r\n  if (!Guid.isGuid(crMessage.commandGuid)) {\r\n    return false;\r\n  }\r\n\r\n  if (!crMessage.data && !crMessage.error) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport function isCommandMessage(message: CommandMessage | any): message is CommandMessage {\r\n  if (!isMessage(message)) {\r\n    return false;\r\n  }\r\n\r\n  const commandMessage = message as CommandMessage;\r\n  if (commandMessage.msgType !== MessageType.Command) {\r\n    return false;\r\n  }\r\n\r\n  if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') {\r\n    return false;\r\n  }\r\n\r\n  if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport function isNotificationMessage(message: NotificationMessage | any): message is NotificationMessage {\r\n  if (!isMessage(message)) {\r\n    return false;\r\n  }\r\n\r\n  const notificationMessage = message as NotificationMessage;\r\n  if (notificationMessage.msgType !== MessageType.Notification) {\r\n    return false;\r\n  }\r\n\r\n  if (!notificationMessage.data || typeof notificationMessage.data !== 'object') {\r\n    return false;\r\n  }\r\n\r\n  if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-messaging/src/MessageTypeChecks.ts\n **/","import {\r\n  ExecuteParameters,\r\n  ExecuteResponse,\r\n  InternalApiDispatcher,\r\n  Model,\r\n  NotificationHandler,\r\n  VerbId,\r\n  VersionNumber,\r\n} from '@tableau/api-internal-contract';\r\nimport { CommandResponseMessage, Messenger, NotificationMessage } from '@tableau/api-messaging';\r\n\r\n/**\r\n * This is an implementation of the InternalApiDispatcher interface which functions by passing messages\r\n * across a frame boundary. This is usually between the code where our javscript library has been included\r\n * by a 3rd party dev and another frame where Tableau server has content.\r\n */\r\nexport class CrossFrameDispatcher implements InternalApiDispatcher {\r\n\r\n  // The api version we are operating through\r\n  private _versionNumber: VersionNumber;\r\n\r\n  // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame,\r\n  // these promises can be either resolved or rejected\r\n  private _pendingPromises: { [messageGuid: string]: { resolve: (response: ExecuteResponse) => void, reject: (error: Model) => void} } = {};\r\n\r\n  // The collection of notification handlers which have been registered with this dispatcher\r\n  private _notificationHandlers: Array<NotificationHandler> = [];\r\n\r\n  /**\r\n   * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate\r\n   * @param _messenger an instantiated and listening messenger object\r\n   */\r\n  public constructor(private _messenger: Messenger) {\r\n    if (!this._messenger) {\r\n      throw 'Missing messenger object';\r\n    }\r\n\r\n    // Set up our message handlers. We only care about incoming notifications and command responses\r\n    this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this));\r\n    this._messenger.setNotificationMessageHandler(this.onNotification.bind(this));\r\n  }\r\n\r\n  ////// Start InternalApiDispatcher implementation\r\n\r\n  public setVersionNumber(versionNumber: VersionNumber): void {\r\n    this._versionNumber = versionNumber;\r\n  }\r\n\r\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\r\n    // To execute a verb, we first prepare a command message and then define a promise.\r\n    const preparedMessage = this._messenger.prepareCommandMessage(verb, parameters);\r\n    const promise = new Promise<ExecuteResponse>((resolve, reject) => {\r\n\r\n      // Save off the pending promise by the messageGuid we are about to send. When a response is\r\n      // received, we'll be able to resolve this promise with the result\r\n      this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject };\r\n    });\r\n\r\n    // Actually send the message and return the promise\r\n    preparedMessage.send();\r\n    return promise;\r\n  }\r\n\r\n  public registerNotificationHandler(handler: NotificationHandler): void {\r\n    this._notificationHandlers.push(handler);\r\n  }\r\n\r\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\r\n    this._notificationHandlers = this._notificationHandlers.filter(h => h !== handler);\r\n  }\r\n\r\n  ////// End InternalApiDispatcher implementation\r\n\r\n  private onCommandResponse(response: CommandResponseMessage): void {\r\n    // We got a command response, look through the pending promises and resolve\r\n    if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) {\r\n      return; // We don't have any reference to this command, just return\r\n    }\r\n\r\n    const pendingPromise = this._pendingPromises[response.commandGuid];\r\n\r\n    // If we have an error defined, reject the promise\r\n    if (response.error) {\r\n      pendingPromise.reject(response.error);\r\n    }\r\n\r\n    // If we have data defined, resolve the promise\r\n    if (response.data) {\r\n      pendingPromise.resolve({result: response.data});\r\n    }\r\n\r\n    // Clean up our pending promises object\r\n    delete this._pendingPromises[response.commandGuid];\r\n  }\r\n\r\n  private onNotification(notificationMessage: NotificationMessage): void {\r\n    // Go through each notification handler we have registered and let them know a notification came in\r\n    for (const handler of this._notificationHandlers) {\r\n      try {\r\n        handler({notificationId: notificationMessage.notificationId, data: notificationMessage.data});\r\n      } catch (e) {\r\n        // Ignore this. Wrap in try/catch so if one handler errors, the other still get the message\r\n      }\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-shared/src/CrossFrame/CrossFrameDispatcher.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\n/**\r\n * Implementation of the external DashboardContent namespace.\r\n * This does not follow the Impl pattern as DashboardContent is\r\n * currently just a (single) property bag.\r\n */\r\nexport class DashboardContent implements Contract.DashboardContent {\r\n  public constructor(private _dashboard: Contract.Dashboard) { }\r\n\r\n  public get dashboard(): Contract.Dashboard {\r\n    return this._dashboard;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Namespaces/DashboardContent.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { ExtensionEnvironment } from '@tableau/api-internal-contract';\r\nimport { InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared';\r\n\r\n/**\r\n * Implementation of the external environment namespace.\r\n * Environment does not follow the Impl pattern as it is\r\n * just a property bag.\r\n */\r\nexport class Environment implements Contract.Environment {\r\n  private _apiVersion: string;\r\n  private _context: Contract.ExtensionContext;\r\n  private _language: string;\r\n  private _locale: string;\r\n  private _mode: Contract.ExtensionMode;\r\n  private _operatingSystem: string;\r\n  private _tableauVersion: string;\r\n\r\n  public constructor(extensionEnvironment: ExtensionEnvironment) {\r\n    this._apiVersion = extensionEnvironment.apiVersion;\r\n    this._context = EnumMappings.extensionContext.convert(extensionEnvironment.extensionContext);\r\n    this._language = extensionEnvironment.extensionLanguage;\r\n    this._locale = extensionEnvironment.extensionLocale;\r\n    this._mode = EnumMappings.extensionMode.convert(extensionEnvironment.extensionMode);\r\n    this._operatingSystem = extensionEnvironment.operatingSystem;\r\n    this._tableauVersion = extensionEnvironment.tableauVersion;\r\n  }\r\n\r\n  public get apiVersion(): string {\r\n    return this._apiVersion;\r\n  }\r\n\r\n  public get context(): Contract.ExtensionContext {\r\n    return this._context;\r\n  }\r\n\r\n  public get language(): string {\r\n    return this._language;\r\n  }\r\n\r\n  public get locale(): string {\r\n    return this._locale;\r\n  }\r\n\r\n  public get mode(): Contract.ExtensionMode {\r\n    return this._mode;\r\n  }\r\n\r\n  public get operatingSystem(): string {\r\n    return this._operatingSystem;\r\n  }\r\n\r\n  public get tableauVersion(): string {\r\n    return this._tableauVersion;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Namespaces/Environment.ts\n **/","import { Settings as SettingsContract } from '@tableau/api-external-contract';\r\n\r\nimport { SettingsImpl } from '../Impl/SettingsImpl';\r\nimport { SettingsCollection } from '../Services/SettingsService';\r\n\r\n/**\r\n * Implementation of the external settings namespace.\r\n */\r\nexport class Settings implements SettingsContract {\r\n  public constructor(private settingsImpl: SettingsImpl) { }\r\n\r\n  public erase(key: string): void {\r\n    this.settingsImpl.erase(key);\r\n  }\r\n\r\n  public get(key: string): string | undefined {\r\n    return this.settingsImpl.get(key);\r\n  }\r\n\r\n  public getAll(): SettingsCollection {\r\n    return this.settingsImpl.getAll();\r\n  }\r\n\r\n  public get isModified(): boolean {\r\n    return this.settingsImpl.isModified;\r\n  }\r\n\r\n  public saveAsync(): Promise<SettingsCollection> {\r\n    return this.settingsImpl.saveAsync();\r\n  }\r\n\r\n  public set(key: string, value: string): void {\r\n    this.settingsImpl.set(key, value);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Namespaces/Settings.ts\n **/","import { InternalApiDispatcher } from '@tableau/api-internal-contract';\r\nimport { ApiServiceRegistry } from '@tableau/api-shared';\r\n\r\nimport { InitializationServiceImpl } from './Impl/InitializationServiceImpl';\r\nimport { SettingsServiceImpl } from  './Impl/SettingsServiceImpl';\r\n\r\nexport function registerAllExtensionsServices(dispatcher: InternalApiDispatcher): void {\r\n  ApiServiceRegistry.instance.registerService(new InitializationServiceImpl(dispatcher));\r\n  ApiServiceRegistry.instance.registerService(new SettingsServiceImpl(dispatcher));\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Services/RegisterAllExtensionsServices.ts\n **/","import { ExtensionBootstrapInfo, InternalApiDispatcher, VerbId } from '@tableau/api-internal-contract';\r\n\r\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\r\nimport { InitializationService } from '../InitializationService';\r\n\r\nexport class InitializationServiceImpl implements InitializationService {\r\n  public constructor(private dispatcher: InternalApiDispatcher) { }\r\n\r\n  public get serviceName(): string {\r\n    return ExtensionsServiceNames.InitializationService;\r\n  }\r\n\r\n  public initializeDashboardExtensionsAsync(): Promise<ExtensionBootstrapInfo> {\r\n    // We don't need any parameters for this call because they are added in for us by the dispatcher\r\n    return this.dispatcher.execute(VerbId.InitializeExtension, {}).then<ExtensionBootstrapInfo>(response => {\r\n      // TODO - Validate return value\r\n\r\n      const result = response.result as ExtensionBootstrapInfo;\r\n      return result;\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Services/Impl/InitializationServiceImpl.ts\n **/","import {\r\n  ExecuteParameters,\r\n  ExtensionSettingsInfo,\r\n  InternalApiDispatcher,\r\n  ParameterId,\r\n  VerbId\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\r\nimport { SettingsCollection, SettingsService } from '../SettingsService';\r\n\r\nexport class SettingsServiceImpl implements SettingsService {\r\n  public constructor(private dispatcher: InternalApiDispatcher) { }\r\n\r\n  public get serviceName(): string {\r\n    return ExtensionsServiceNames.SettingsService;\r\n  }\r\n\r\n  public saveSettingsAsync(settings: SettingsCollection): Promise<SettingsCollection> {\r\n    const parameters: ExecuteParameters = {[ParameterId.SettingsValues]: settings};\r\n\r\n    return this.dispatcher.execute(VerbId.SaveExtensionSettings, parameters).then<SettingsCollection>(value => {\r\n      const result = value.result as ExtensionSettingsInfo;\r\n\r\n      if (!result || !result.settingsValues) {\r\n        throw TableauException.internalError(['saving settings.']);\r\n      }\r\n\r\n      return(result.settingsValues);\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Services/Impl/SettingsServiceImpl.ts\n **/","import { ExtensionSettingsInfo } from '@tableau/api-internal-contract';\r\nimport { ApiServiceRegistry } from '@tableau/api-shared';\r\nimport { Param, TableauException } from '@tableau/api-utils';\r\n\r\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\r\nimport { SettingsCollection, SettingsService } from '../Services/SettingsService';\r\n\r\nexport class SettingsImpl {\r\n  private static ASYNC_SAVE_IN_PROGRESS: string = 'Async Save is in progress, updating settings is not allowed.';\r\n  private _isModified: boolean;\r\n  private _currentSettings: SettingsCollection;\r\n\r\n  // Since promises can't be introspected for state, keep a variable that\r\n  // indicates a save is in progress, so that set/erase can't be called during a save.\r\n  private _saveInProgress: boolean = false;\r\n\r\n  public constructor(settingsInfo: ExtensionSettingsInfo) {\r\n    this.initializeSettings(settingsInfo);\r\n  }\r\n\r\n  public erase(key: string): void {\r\n    Param.verifyValue(key, 'key');\r\n\r\n    // Only make a modification if we have the key already\r\n    if (this._currentSettings[key]) {\r\n      this.verifySettingsAreUnlocked();\r\n\r\n      delete this._currentSettings[key];\r\n      this._isModified = true;\r\n    }\r\n  }\r\n\r\n  public get(key: string): string | undefined {\r\n    Param.verifyValue(key, 'key');\r\n    return this._currentSettings[key];\r\n  }\r\n\r\n  public getAll(): SettingsCollection {\r\n    // Returns a mutable copy of the settings\r\n    return Object.assign({}, this._currentSettings);\r\n  }\r\n\r\n  public get isModified(): boolean {\r\n    return this._isModified;\r\n  }\r\n\r\n  public saveAsync(): Promise<SettingsCollection> {\r\n    this.verifySettingsAreUnlocked();\r\n\r\n    // Just resolve immediately if settings are unchanged\r\n    if (!this._isModified) {\r\n      return Promise.resolve<SettingsCollection>(this._currentSettings);\r\n    }\r\n\r\n    this._saveInProgress = true;\r\n\r\n    // Use the settings service to save settings to twb\r\n    const settingsService = ApiServiceRegistry.instance.getService<SettingsService>(\r\n      ExtensionsServiceNames.SettingsService);\r\n\r\n    return settingsService.saveSettingsAsync(this._currentSettings).then<SettingsCollection>(newSettings => {\r\n      this._saveInProgress = false;\r\n      this._isModified = false;\r\n      Object.assign(this._currentSettings, newSettings);\r\n      return newSettings;\r\n    });\r\n  }\r\n\r\n  public set(key: string, value: string): void {\r\n    Param.verifyValue(key, 'key'); // Key shouldn't be an empty string.\r\n    Param.verifyString(value, 'value'); // Empty string value is allowed.\r\n    this.verifySettingsAreUnlocked();\r\n\r\n    this._currentSettings[key] = value;\r\n    this._isModified = true;\r\n  }\r\n\r\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): void {\r\n    Param.verifyValue(settingsInfo, 'settingsInfo');\r\n    Param.verifyValue(settingsInfo.settingsValues, 'settingsInfo.SettingsValues');\r\n\r\n    this._currentSettings = settingsInfo.settingsValues;\r\n\r\n    // Reset the isModified flag\r\n    this._isModified = false;\r\n  }\r\n\r\n  /**\r\n   * This helper should be called before any local update to this.currentSettings.\r\n   * Checks if a current save call is still in progress and throws an error if so.\r\n   */\r\n  private verifySettingsAreUnlocked(): void {\r\n    if (this._saveInProgress) {\r\n      throw TableauException.error(SettingsImpl.ASYNC_SAVE_IN_PROGRESS);\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Impl/SettingsImpl.ts\n **/","import * as Contract from '@tableau/api-external-contract';\r\n\r\nimport { ExtensionsImpl } from '../Impl/ExtensionsImpl';\r\n\r\n/**\r\n * Implementation of the external Extensions namespace.\r\n */\r\nexport class Extensions implements Contract.Extensions {\r\n  public constructor(private extensionImpl: ExtensionsImpl) {\r\n    this.extensionImpl = extensionImpl;\r\n  }\r\n\r\n  public get dashboardContent(): Contract.DashboardContent {\r\n    return this.extensionImpl.dashboardContent;\r\n  }\r\n\r\n  public get environment(): Contract.Environment {\r\n    return this.extensionImpl.environment;\r\n  }\r\n\r\n  public get settings(): Contract.Settings {\r\n    return this.extensionImpl.settings;\r\n  }\r\n\r\n  public get ui(): Contract.UI {\r\n    throw new Error('API call not yet implemented');\r\n  }\r\n\r\n  public initializeAsync(): Promise<void> {\r\n    return this.extensionImpl.initializeAsync();\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/extensions-api/src/Namespaces/Extensions.ts\n **/","import { ApiEventHandler } from '@tableau/api-core';\r\nimport { InternalApiDispatcher, InternalApiDispatcherHolder } from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { AddInApiPresLayerImpl } from './AddInApiPresLayerImpl';\r\nimport { DesktopApiDispatcher } from './DesktopApiDispatcher';\r\nimport { hasQt, initializeWebChannelPresLayer } from './QtWebChannelImpl';\r\n\r\n/**\r\n * Wrapper for all the bootstrapping logic. This code attempts to initialize the qt pres-layer\r\n * as well as the desktop dispatcher. It then assigns it to the global desktop dispatcher to\r\n * be picked up by the add-in external Api\r\n */\r\nexport function doBootstrap(): Promise<InternalApiDispatcher> {\r\n  if (!hasQt()) {\r\n    return Promise.reject('Not running in desktop with qt available');\r\n  }\r\n\r\n  // First we need to initialize the webchannel pres-layer\r\n  let dispatcherPromise = initializeWebChannelPresLayer().then<InternalApiDispatcher>((preslayer) => {\r\n    const presLayerApi = new AddInApiPresLayerImpl(preslayer);\r\n    if (!presLayerApi.AddInInstanceInfo.addInLocatorPresModel) {\r\n      throw TableauException.isUndefined(['AddInInstanceInfo']);\r\n    }\r\n\r\n    // Initialize the apiEventHandler and the desktopDispatcher with it\r\n    const apiEventHandler = new ApiEventHandler(presLayerApi, presLayerApi.AddInInstanceInfo.addInLocatorPresModel, true);\r\n    const desktopDispatcher = new DesktopApiDispatcher(apiEventHandler);\r\n\r\n    return desktopDispatcher;\r\n  });\r\n\r\n  // Assign the desktop dispatcher for the other project to find it\r\n  InternalApiDispatcherHolder.setDesktopDispatcherPromise(dispatcherPromise);\r\n\r\n  return dispatcherPromise;\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** ../src/FrelardDesktopBootstrap.ts\n **/","/**\r\n * This is your main. This is where you re-export everything you want to be publicly available.\r\n *\r\n * The build enforces that the file has the same name as the global variable that is exported.\r\n */\r\n\r\nexport * from './ApiEventHandler';\r\n\r\n// Need to export these two pres models for use by other projects\r\nexport {\r\n  AddInInstancePresModel,\r\n  AddInLocatorPresModel,\r\n  AddInBootstrapInfoPresModel,\r\n  PresentationModel\r\n} from '../gen-src/preslayer/PresModels';\r\nexport { NotificationId } from '../gen-src/preslayer/Events';\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/ApiCore.ts\n **/","import {\r\n  ExecuteParameters,\r\n  ExecuteResponse,\r\n  ExtensionLocator as ApiExtensionLocator,\r\n  Model,\r\n  NotificationId,\r\n  ParameterId as ApiParameterId,\r\n  VerbId,\r\n  VersionNumber,\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\nimport { PresentationLayer } from '@tableau/preslayer-api-contract';\r\n\r\nimport { NotificationId as PresLayerEventId } from '../gen-src/preslayer/Events';\r\nimport { ParameterId as PresLayerParameterId } from '../gen-src/preslayer/Params';\r\nimport { AddInLocatorPresModel, PresentationModel } from '../gen-src/preslayer/PresModels';\r\nimport { CommandMappingRegistry } from './mappings/CommandMappingRegistry';\r\nimport { CommandMappingRegistryFactory } from './mappings/CommandMappingRegistryFactory';\r\nimport { EventMappingRegistry, EventMappingRegistryFactory } from './mappings/EventMappingRegistryFactory';\r\nimport {\r\n  ApiToPresLayerMappingRegistry,\r\n  ParameterMappingRegistryFactory,\r\n  PresLayerToApiMappingRegistry,\r\n} from './mappings/ParameterMappingRegistryFactory';\r\n\r\nexport type NotificationHandler = (notification: NotificationId, model: Model) => void;\r\n\r\n/**\r\n * Main class for the api-core project. This class is responsible for executing comamnd and marshalling notifications\r\n * between the internal Api and the pres-layer Api. After construction, SetVersionNumber must be called in order to\r\n * use this class\r\n *\r\n * @export\r\n * @class ApiEventHandler\r\n */\r\nexport class ApiEventHandler {\r\n  private static VERSION_NOT_CONFIGURED: string = 'VersionNumber not yet configured. Cannot take any actions';\r\n  private _apiExtensionLocator: ApiExtensionLocator;\r\n  private _eventHandler: NotificationHandler;\r\n  private _commandRegistry: CommandMappingRegistry;\r\n  private _eventRegistry: EventMappingRegistry;\r\n  private _apiToPresLayerRegistry: ApiToPresLayerMappingRegistry;\r\n  private _presLayerToApiRegistry: PresLayerToApiMappingRegistry;\r\n  private _versionNumber?: VersionNumber;\r\n\r\n  /**\r\n   * Creates an instance of ApiEventHandler.\r\n   * @param {PresentationLayer} presLayer - An implementation of the pres-layer Api to use\r\n   * @param {AddInLocatorPresModel} addInLocatorPresModel - locator for the add-in which is being referenced\r\n   * @param {runningInDesktop} boolean - true if this is ApiEventHandler is created in a Desktop context.\r\n   * @memberof ApiEventHandler\r\n   */\r\n  constructor(private _presLayer: PresentationLayer,\r\n              private _presLayerAddInLocator: AddInLocatorPresModel,\r\n              private _runningInDesktop: boolean) { }\r\n\r\n  /**\r\n   * Sets the internal Api version number which the external library is expecting to use. This must be called before\r\n   * anything else in order to properly set up the translation layers.\r\n   *\r\n   * @param {VersionNumber} versionNumber\r\n   * @memberof ApiEventHandler\r\n   */\r\n  public setVersionNumber(versionNumber: VersionNumber): void {\r\n    this._versionNumber = versionNumber;\r\n\r\n    // Initialize all our registries\r\n    this._commandRegistry = CommandMappingRegistryFactory.createCommandMappingRegistry(versionNumber, this._runningInDesktop);\r\n    this._apiToPresLayerRegistry = ParameterMappingRegistryFactory.createApiToPresLayerParamRegistry(versionNumber);\r\n    this._presLayerToApiRegistry = ParameterMappingRegistryFactory.createPresLayerToApiParamRegistry(versionNumber);\r\n    this._eventRegistry = EventMappingRegistryFactory.createEventMappingRegistry(versionNumber);\r\n\r\n    // Convert our addInLocator to the Api version\r\n    this._apiExtensionLocator = this._presLayerToApiRegistry\r\n      .get(PresLayerParameterId.AddInLocator, ApiParameterId.ExtensionLocator)(this._presLayerAddInLocator) as ApiExtensionLocator;\r\n\r\n    for (const plEventId of Object.keys(this._eventRegistry)) {\r\n      // Register for all notifications we know about and bind the event type to the callback\r\n      this._presLayer.registerNotificationHandler(plEventId, this.onPresLayerNotification.bind(this, plEventId));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets an event handler function to be notified when Api events come in. Only a single registration is supported.\r\n   *\r\n   * @param {NotificationHandler} eventHandler\r\n   * @memberof ApiEventHandler\r\n   */\r\n  public setEventHandler(eventHandler: NotificationHandler): void {\r\n    this._eventHandler = eventHandler;\r\n\r\n    // TODO - Register for pres layer events\r\n  }\r\n\r\n  /**\r\n   * Executes the requested Api command by converting the parameters, running the command against the pres-layer,\r\n   * then processing the result back into a format the Api can understand\r\n   *\r\n   * @param {VerbId} verb\r\n   * @param {ExecuteParameters} parameters\r\n   * @returns {Promise<ExecuteResponse>}\r\n   * @memberof ApiEventHandler\r\n   */\r\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\r\n    this.assertInitialized();\r\n\r\n    const command = this._commandRegistry.getCommand(verb);\r\n    parameters = parameters || {};\r\n\r\n    // Augment the command with the locator if it's needed\r\n    if (command.needsAddInLocator) {\r\n      parameters[ApiParameterId.ExtensionLocator] = this._apiExtensionLocator;\r\n    }\r\n\r\n    const commandsParams = command.createParams(parameters, this._apiToPresLayerRegistry);\r\n\r\n    return this._presLayer.invokeCommand<{[docParamId: string]: object}>(command.namespace, command.commandId, commandsParams)\r\n    .then<ExecuteResponse>((commandResult) => {\r\n      const convertedResult = command.ProcessResult(commandResult, this._presLayerToApiRegistry);\r\n      return {\r\n        result: convertedResult\r\n      };\r\n    });\r\n  }\r\n\r\n  public get ApiExtensionLocator(): ApiExtensionLocator {\r\n    return this._apiExtensionLocator;\r\n  }\r\n\r\n  /**\r\n   * Helper method to check that things are initialized as expected. Throws if initialization not complete\r\n   *\r\n   * @private\r\n   * @memberof ApiEventHandler\r\n   */\r\n  private assertInitialized(): void {\r\n    if (!this._versionNumber) {\r\n      throw TableauException.error(ApiEventHandler.VERSION_NOT_CONFIGURED);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Called when a new event notification comes in from the presentation layer\r\n   *\r\n   * @param eventId The pres layer event id\r\n   * @param presModel The pres model that is included with the event\r\n   */\r\n  private onPresLayerNotification(eventId: PresLayerEventId, presModel: PresentationModel): void {\r\n    // First look up this eventId in our registry and convert to presModel\r\n    const eventMapping = this._eventRegistry[eventId];\r\n    const apiModel = eventMapping.converter(presModel);\r\n\r\n    if (this._eventHandler) {\r\n      this._eventHandler(eventMapping.apiId, apiModel);\r\n    }\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/ApiEventHandler.ts\n **/","// -----------------------------------------------------------------------------\r\n//\r\n// This file is the copyrighted property of Tableau Software and is protected\r\n// by registered patents and other applicable U.S. and international laws and\r\n// regulations.\r\n//\r\n// Unlicensed use of the contents of this file is prohibited. Please refer to\r\n// the NOTICES.txt file for further details.\r\n//\r\n// -----------------------------------------------------------------------------\r\n// WARNING: Computer generated file.  Do not hand modify.\r\n// DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/params-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-params.data']\r\n\r\nexport enum ParameterId {\r\n\r\n  // DPI_IntegerRLE, having type int[]\r\n  IntegerRLE = 'intRle',\r\n\r\n  // DPI_UnsignedIntegerRLE, having type uint[]\r\n  UnsignedIntegerRLE = 'uintRle',\r\n\r\n  // DPI_FloatRLE, having type float[]\r\n  FloatRLE = 'floatRle',\r\n\r\n  // DPI_ParameterID, having type string\r\n  ParameterID = 'paramType',\r\n\r\n  // DPI_AllowCustomDatabase, having type bool\r\n  AllowCustomDatabase = 'allowCustomDatabase',\r\n\r\n  // DPI_AllowCustomSchema, having type bool\r\n  AllowCustomSchema = 'allowCustomSchema',\r\n\r\n  // DPI_AllowCustomSQL, having type bool\r\n  AllowCustomSQL = 'allowCustomSql',\r\n\r\n  // DPI_AllowCustomSQLWithoutSchema, having type bool\r\n  AllowCustomSQLWithoutSchema = 'allowCustomSqlWithoutSchema',\r\n\r\n  // DPI_AllowPreviewData, having type bool\r\n  AllowPreviewData = 'allowPreviewData',\r\n\r\n  // DPI_AllowStoredProc, having type bool\r\n  AllowStoredProc = 'allowStoredProcedure',\r\n\r\n  // DPI_AllowUnion, having type bool\r\n  AllowUnion = 'allowUnion',\r\n\r\n  // DPI_AreVariablesVisible, having type bool\r\n  AreVariablesVisible = 'areVariablesVisible',\r\n\r\n  // DPI_AttrLegacyConnection, having type bool\r\n  AttrLegacyConnection = 'widgetAttrLegacy',\r\n\r\n  // DPI_AttrReadUncommitted, having type bool\r\n  AttrReadUncommitted = 'widgetAttrReadUncommittedData',\r\n\r\n  // DPI_AttrRequireSSL, having type bool\r\n  AttrRequireSSL = 'widgetAttrRequireSsl',\r\n\r\n  // DPI_AttrRequireEncryption, having type bool\r\n  AttrRequireEncryption = 'widgetAttrRequireEncryption',\r\n\r\n  // DPI_Bool, having type bool\r\n  Bool = 'bool',\r\n\r\n  // DPI_CanPartition, having type bool\r\n  CanPartition = 'canPartition',\r\n\r\n  // DPI_CanRecommendDataSources, having type bool\r\n  CanRecommendDataSources = 'canRecommendDatasources',\r\n\r\n  // DPI_CanRecommendTables, having type bool\r\n  CanRecommendTables = 'canRecommendTables',\r\n\r\n  // DPI_CheckPermissions, having type bool\r\n  CheckPermissions = 'checkPermissions',\r\n\r\n  // DPI_DatabaseNameOptional, having type bool\r\n  DatabaseNameOptional = 'databaseNameOptional',\r\n\r\n  // DPI_DatabaseWHOptional, having type bool\r\n  DatabaseWHOptional = 'databaseWarehouseOptional',\r\n\r\n  // DPI_DoValidation, having type bool\r\n  DoValidation = 'doValidation',\r\n\r\n  // DPI_DoneLoadingAllSheets, having type bool\r\n  DoneLoadingAllSheets = 'googleSheetDoneLoading',\r\n\r\n  // DPI_GABasicItemsEnabled, having type bool\r\n  GABasicItemsEnabled = 'gaBasicItemsEnabled',\r\n\r\n  // DPI_GADimensionMeasuresEnabled, having type bool\r\n  GADimensionMeasuresEnabled = 'gaDimensionsMeasuresEnabled',\r\n\r\n  // DPI_GAFiltersEnabled, having type bool\r\n  GAFiltersEnabled = 'gaFiltersEnabled',\r\n\r\n  // DPI_HasDatabase, having type bool\r\n  HasDatabase = 'hasDatabase',\r\n\r\n  // DPI_HasDataLoss, having type bool\r\n  HasDataLoss = 'hasDataLoss',\r\n\r\n  // DPI_HasFastMetadata, having type bool\r\n  HasFastMetadata = 'hasFastMetadata',\r\n\r\n  // DPI_HasNewlyDiscoveredSchema, having type bool\r\n  HasNewlyDiscoveredSchema = 'hasNewlyDiscoveredSchema',\r\n\r\n  // DPI_HasPermissions, having type bool\r\n  HasPermissions = 'hasPermissions',\r\n\r\n  // DPI_HasSchema, having type bool\r\n  HasSchema = 'hasSchema',\r\n\r\n  // DPI_HasSchemaCount, having type bool\r\n  HasSchemaCount = 'hasSchemaCount',\r\n\r\n  // DPI_HasTables, having type bool\r\n  HasTables = 'hasTables',\r\n\r\n  // DPI_HasUncommittedChanges, having type bool\r\n  HasUncommittedChanges = 'hasUncommittedChanges',\r\n\r\n  // DPI_HasWarehouse, having type bool\r\n  HasWarehouse = 'hasWarehouse',\r\n\r\n  // DPI_HasWarning, having type bool\r\n  HasWarning = 'hasWarning',\r\n\r\n  // DPI_IsCalculated, having type bool\r\n  IsCalculated = 'isCalculated',\r\n\r\n  // DPI_IsConnectedToDataSource, having type bool\r\n  IsConnectedToDataSource = 'isConnectedDatasource',\r\n\r\n  // DPI_IsDisabledDataConnection, having type bool\r\n  IsDisabledDataConnection = 'isDisabledDataConnection',\r\n\r\n  // DPI_IsEditable, having type bool\r\n  IsEditable = 'isEditable',\r\n\r\n  // DPI_IsEnabled, having type bool\r\n  IsEnabled = 'isEnabled',\r\n\r\n  // DPI_IsFinishedConnecting, having type bool\r\n  IsFinishedConnecting = 'isFinishedConnecting',\r\n\r\n  // DPI_IsHidden, having type bool\r\n  IsHidden = 'isHidden',\r\n\r\n  // DPI_IsMultiTable, having type bool\r\n  IsMultiTable = 'isMultiTable',\r\n\r\n  // DPI_IsNewCustomSQL, having type bool\r\n  IsNewCustomSQL = 'isNewCustomSql',\r\n\r\n  // DPI_IsNewDataSource, having type bool\r\n  IsNewDataSource = 'isNewDataSrc',\r\n\r\n  // DPI_IsPublishedFederated, having type bool\r\n  IsPublishedFederated = 'isPublishedFederated',\r\n\r\n  // DPI_IsSampled, having type bool\r\n  IsSampled = 'isSampled',\r\n\r\n  // DPI_IsSchemaMemberNewlyDiscovered, having type bool\r\n  IsSchemaMemberNewlyDiscovered = 'isSchemaMemberNewlyDiscovered',\r\n\r\n  // DPI_IsSlowFast, having type bool\r\n  IsSlowFast = 'isSlowfast',\r\n\r\n  // DPI_IsSupported, having type bool\r\n  IsSupported = 'isSupported',\r\n\r\n  // DPI_IsTableSelectionVisible, having type bool\r\n  IsTableSelectionVisible = 'isTableSelectionVisible',\r\n\r\n  // DPI_IsTableauServerDatasource, having type bool\r\n  IsTableauServerDatasource = 'isTableauServerDatasource',\r\n\r\n  // DPI_IsTableauServerDatasourceConnectable, having type bool\r\n  IsTableauServerDatasourceConnectable = 'isTableauServerDatasourceConnectable',\r\n\r\n  // DPI_IsTableauServerDatasourceDownloadable, having type bool\r\n  IsTableauServerDatasourceDownloadable = 'isTableauServerDatasourceDownloadable',\r\n\r\n  // DPI_IsVisible, having type bool\r\n  IsVisible = 'isVisible',\r\n\r\n  // DPI_NeedFlatten, having type bool\r\n  NeedFlatten = 'needFlatten',\r\n\r\n  // DPI_SSLRequiresCertificate, having type bool\r\n  SSLRequiresCertificate = 'sslRequiresCertificate',\r\n\r\n  // DPI_SchemaOptional, having type bool\r\n  SchemaOptional = 'schemaOptional',\r\n\r\n  // DPI_ServiceNameOptional, having type bool\r\n  ServiceNameOptional = 'serviceNameOptional',\r\n\r\n  // DPI_ShouldWarnForCrossSchemaJoins, having type bool\r\n  ShouldWarnForCrossSchemaJoins = 'shouldWarnCrossSchemaJoins',\r\n\r\n  // DPI_ShowBrowseButton, having type bool\r\n  ShowBrowseButton = 'showBrowseButton',\r\n\r\n  // DPI_ShowConnectionPrompt, having type bool\r\n  ShowConnectionPrompt = 'showConnectionPrompt',\r\n\r\n  // DPI_ShowDBBrowseButton, having type bool\r\n  ShowDBBrowseButton = 'showDbBrowseButton',\r\n\r\n  // DPI_ShowDBNamePrompt, having type bool\r\n  ShowDBNamePrompt = 'showDbPrompt',\r\n\r\n  // DPI_ShowDBWHNamePrompt, having type bool\r\n  ShowDBWHNamePrompt = 'showDbwhPrompt',\r\n\r\n  // DPI_ShowImportSSLCertLabel, having type bool\r\n  ShowImportSSLCertLabel = 'showImportSslcertLabel',\r\n\r\n  // DPI_ShowPortPrompt, having type bool\r\n  ShowPortPrompt = 'showPortPrompt',\r\n\r\n  // DPI_ShowSSLCheckbox, having type bool\r\n  ShowSSLCheckbox = 'showSslCheckbox',\r\n\r\n  // DPI_ShowEncryptionCheckbox, having type bool\r\n  ShowEncryptionCheckbox = 'showEncryptionCheckbox',\r\n\r\n  // DPI_ShowServerNamePrompt, having type bool\r\n  ShowServerNamePrompt = 'showServerPrompt',\r\n\r\n  // DPI_ShowServiceNamePrompt, having type bool\r\n  ShowServiceNamePrompt = 'showServicePrompt',\r\n\r\n  // DPI_ShowUncommittedDataCheckbox, having type bool\r\n  ShowUncommittedDataCheckbox = 'showUncommittedDataCheckbox',\r\n\r\n  // DPI_SupportsGenericAuth, having type bool\r\n  SupportsGenericAuth = 'supportsGenericAuth',\r\n\r\n  // DPI_TableauServerFetchAscending, having type bool\r\n  TableauServerFetchAscending = 'tableauServerFetchAscending',\r\n\r\n  // DPI_UsesRadioButton, having type bool\r\n  UsesRadioButton = 'usesRadioButton',\r\n\r\n  // DPI_BigQueryLegacySQLCheckStatus, having type bool\r\n  BigQueryLegacySQLCheckStatus = 'datasourceBigqueryLegacySqlCheckStatus',\r\n\r\n  // DPI_HasBigQueryLegacySQLCheck, having type bool\r\n  HasBigQueryLegacySQLCheck = 'datasourceBigqueryLegacySqlCheck',\r\n\r\n  // DPI_AutoFetchLimit, having type int\r\n  AutoFetchLimit = 'autoFetchLimit',\r\n\r\n  // DPI_ConnectionType, having type int\r\n  ConnectionType = 'connectionType',\r\n\r\n  // DPI_IconId, having type int\r\n  IconId = 'iconId',\r\n\r\n  // DPI_SelectedCatalogIndex, having type int\r\n  SelectedCatalogIndex = 'selectedCatalogIndex',\r\n\r\n  // DPI_SelectedCubeIndex, having type int\r\n  SelectedCubeIndex = 'selectedCubeIndex',\r\n\r\n  // DPI_SelectedGAAccountIndex, having type int\r\n  SelectedGAAccountIndex = 'selectedGaAccountIndex',\r\n\r\n  // DPI_SelectedGAMeasureSetIndex, having type int\r\n  SelectedGAMeasureSetIndex = 'selectedGaMeasureSetIndex',\r\n\r\n  // DPI_SelectedGAPropertyIndex, having type int\r\n  SelectedGAPropertyIndex = 'selectedGaPropertyIndex',\r\n\r\n  // DPI_SelectedGASegmentIndex, having type int\r\n  SelectedGASegmentIndex = 'selectedGaSegmentIndex',\r\n\r\n  // DPI_SelectedGAViewIndex, having type int\r\n  SelectedGAViewIndex = 'selectedGaViewIndex',\r\n\r\n  // DPI_SelectedGoogleSheetIndex, having type int\r\n  SelectedGoogleSheetIndex = 'selectedGoogleSheetIndex',\r\n\r\n  // DPI_SelectedOptionIndex, having type int\r\n  SelectedOptionIndex = 'selectedOptionIndex',\r\n\r\n  // DPI_SlowMetadataCount, having type int\r\n  SlowMetadataCount = 'slowMetadataCount',\r\n\r\n  // DPI_TableauServerFetchSortBy, having type int\r\n  TableauServerFetchSortBy = 'tableauServerFetchSort',\r\n\r\n  // DPI_ActualParameterOrdinal, having type uint\r\n  ActualParameterOrdinal = 'actualParameterOrdinal',\r\n\r\n  // DPI_ActualParameterType, having type uint\r\n  ActualParameterType = 'actualParameterType',\r\n\r\n  // DPI_CharSetID, having type uint\r\n  CharSetID = 'charsetId',\r\n\r\n  // DPI_DataSourceOrdinal, having type uint\r\n  DataSourceOrdinal = 'datasourceOrdinal',\r\n\r\n  // DPI_FilterCount, having type uint\r\n  FilterCount = 'filterCount',\r\n\r\n  // DPI_VariablesCount, having type uint\r\n  VariablesCount = 'variablesCount',\r\n\r\n  // DPI_ActualParameterDisplayName, having type string\r\n  ActualParameterDisplayName = 'actualParameterDisplayName',\r\n\r\n  // DPI_ActualParameterName, having type string\r\n  ActualParameterName = 'actualParameterName',\r\n\r\n  // DPI_ActualParameterValue, having type string\r\n  ActualParameterValue = 'actualParameterValue',\r\n\r\n  // DPI_AttrAPIVersion, having type string\r\n  AttrAPIVersion = 'attrApiVersion',\r\n\r\n  // DPI_AttrAuthType, having type string\r\n  AttrAuthType = 'widgetAttrAuthtype',\r\n\r\n  // DPI_AttrAuthenticator, having type string\r\n  AttrAuthenticator = 'widgetAttrAuthenticator',\r\n\r\n  // DPI_AttrConnectionData, having type string\r\n  AttrConnectionData = 'attrConnectionData',\r\n\r\n  // DPI_AttrConnectionName, having type string\r\n  AttrConnectionName = 'attrConnectionName',\r\n\r\n  // DPI_AttrConnectionType, having type string\r\n  AttrConnectionType = 'widgetAttrConnectiontype',\r\n\r\n  // DPI_AttrConnectionURL, having type string\r\n  AttrConnectionURL = 'attrConnectionUrl',\r\n\r\n  // DPI_AttrCubeSpecificationId, having type string\r\n  AttrCubeSpecificationId = 'widgetAttrCubeSpecificationId',\r\n\r\n  // DPI_AttrCubeSpecificationValue, having type string\r\n  AttrCubeSpecificationValue = 'widgetAttrCubeSpecificationValue',\r\n\r\n  // DPI_AttrDSN, having type string\r\n  AttrDSN = 'widgetAttrDsn',\r\n\r\n  // DPI_AttrDatabase, having type string\r\n  AttrDatabase = 'widgetAttrDb',\r\n\r\n  // DPI_AttrDatabaseWarehouse, having type string\r\n  AttrDatabaseWarehouse = 'widgetAttrDbwh',\r\n\r\n  // DPI_AttrDriver, having type string\r\n  AttrDriver = 'widgetAttrDriver',\r\n\r\n  // DPI_AttrFilename, having type string\r\n  AttrFilename = 'widgetAttrFilename',\r\n\r\n  // DPI_AttrHTTPPath, having type string\r\n  AttrHTTPPath = 'widgetAttrHttpPath',\r\n\r\n  // DPI_AttrIncrementalRefreshKey, having type string\r\n  AttrIncrementalRefreshKey = 'attrIncrementalRefreshKey',\r\n\r\n  // DPI_AttrKerberosHost, having type string\r\n  AttrKerberosHost = 'widgetAttrKerberosHost',\r\n\r\n  // DPI_AttrKerberosRealm, having type string\r\n  AttrKerberosRealm = 'widgetAttrKerberosRealm',\r\n\r\n  // DPI_AttrKerberosService, having type string\r\n  AttrKerberosService = 'widgetAttrKerberosService',\r\n\r\n  // DPI_AttrLastRecordToken, having type string\r\n  AttrLastRecordToken = 'attrLastRecordToken',\r\n\r\n  // DPI_AttrMDWPath, having type string\r\n  AttrMDWPath = 'widgetAttrMdwPath',\r\n\r\n  // DPI_AttrMDWUsername, having type string\r\n  AttrMDWUsername = 'widgetAttrMdwUsername',\r\n\r\n  // DPI_AttrODBCPrompt, having type string\r\n  AttrODBCPrompt = 'widgetAttrOdbcPrompt',\r\n\r\n  // DPI_AttrODBCStringExtras, having type string\r\n  AttrODBCStringExtras = 'widgetAttrOdbcStringExtras',\r\n\r\n  // DPI_AttrPort, having type string\r\n  AttrPort = 'widgetAttrPort',\r\n\r\n  // DPI_AttrSAPClient, having type string\r\n  AttrSAPClient = 'widgetAttrSapClient',\r\n\r\n  // DPI_AttrSAPLanguage, having type string\r\n  AttrSAPLanguage = 'widgetAttrSapLanguage',\r\n\r\n  // DPI_AttrEdition, having type string\r\n  AttrEdition = 'widgetAttrSslEdition',\r\n\r\n  // DPI_AttrSSODomain, having type string\r\n  AttrSSODomain = 'widgetAttrSsoDomain',\r\n\r\n  // DPI_AttrSSLCert, having type string\r\n  AttrSSLCert = 'widgetAttrSslCert',\r\n\r\n  // DPI_AttrScriptVersion, having type string\r\n  AttrScriptVersion = 'attrScriptVersion',\r\n\r\n  // DPI_AttrServer, having type string\r\n  AttrServer = 'widgetAttrServer',\r\n\r\n  // DPI_AttrService, having type string\r\n  AttrService = 'widgetAttrService',\r\n\r\n  // DPI_AttrUsername, having type string\r\n  AttrUsername = 'widgetAttrUser',\r\n\r\n  // DPI_AuthenticationPrompt, having type string\r\n  AuthenticationPrompt = 'authenticationPrompt',\r\n\r\n  // DPI_ButtonClickAction, having type string\r\n  ButtonClickAction = 'buttonClickAction',\r\n\r\n  // DPI_ButtonCaption, having type string\r\n  ButtonCaption = 'buttonCaption',\r\n\r\n  // DPI_ButtonImagePath, having type string\r\n  ButtonImagePath = 'buttonImagePath',\r\n\r\n  // DPI_ButtonImagePathKey, having type string\r\n  ButtonImagePathKey = 'buttonImagePathKey',\r\n\r\n  // DPI_Caption, having type string\r\n  Caption = 'caption',\r\n\r\n  // DPI_CatalogListPrompt, having type string\r\n  CatalogListPrompt = 'catalogListPrompt',\r\n\r\n  // DPI_CatalogName, having type string\r\n  CatalogName = 'catalogName',\r\n\r\n  // DPI_CatalogSearchTerm, having type string\r\n  CatalogSearchTerm = 'catalogSearchTerm',\r\n\r\n  // DPI_Category, having type string\r\n  Category = 'itemCategory',\r\n\r\n  // DPI_ClassName, having type string\r\n  ClassName = 'classNameForCleaning',\r\n\r\n  // DPI_CloudFileClassName, having type string\r\n  CloudFileClassName = 'cloudFileClassName',\r\n\r\n  // DPI_CloudFileStorageProvider, having type string\r\n  CloudFileStorageProvider = 'cloudFileStorageProvider',\r\n\r\n  // DPI_ConfigName, having type string\r\n  ConfigName = 'connectionConfigName',\r\n\r\n  // DPI_ConnectionCaption, having type string\r\n  ConnectionCaption = 'connectionCaption',\r\n\r\n  // DPI_ConnectionDescriptionLabel, having type string\r\n  ConnectionDescriptionLabel = 'connectionDescriptionLabel',\r\n\r\n  // DPI_ConnectionClass, having type string\r\n  ConnectionClass = 'connectionClassName',\r\n\r\n  // DPI_ConnectionName, having type string\r\n  ConnectionName = 'connectionName',\r\n\r\n  // DPI_ConnectionOptionName, having type string\r\n  ConnectionOptionName = 'connectionOptionName',\r\n\r\n  // DPI_ConnectionSpecificationTitle, having type string\r\n  ConnectionSpecificationTitle = 'connectionSpecificationTitle',\r\n\r\n  // DPI_ConnectionTypeLabel, having type string\r\n  ConnectionTypeLabel = 'connectionTypeLabel',\r\n\r\n  // DPI_ConnectionURI, having type string\r\n  ConnectionURI = 'connectionUri',\r\n\r\n  // DPI_CubeDescription, having type string\r\n  CubeDescription = 'cubeDescription',\r\n\r\n  // DPI_CubeLastUpdated, having type string\r\n  CubeLastUpdated = 'cubeLastUpdated',\r\n\r\n  // DPI_CubeListPrompt, having type string\r\n  CubeListPrompt = 'cubeListPrompt',\r\n\r\n  // DPI_CubeName, having type string\r\n  CubeName = 'cubeName',\r\n\r\n  // DPI_CubeSearchTerm, having type string\r\n  CubeSearchTerm = 'cubeSearchTerm',\r\n\r\n  // DPI_CurrentText, having type string\r\n  CurrentText = 'currentText',\r\n\r\n  // DPI_CustomSplitStringSeparator, having type string\r\n  CustomSplitStringSeparator = 'customSplitStringSeparator',\r\n\r\n  // DPI_DatasourceId, having type string\r\n  DatasourceId = 'datasourceId',\r\n\r\n  // DPI_DBNamePrompt, having type string\r\n  DBNamePrompt = 'dbNamePrompt',\r\n\r\n  // DPI_DBWHNamePrompt, having type string\r\n  DBWHNamePrompt = 'dbWarehouseNamePrompt',\r\n\r\n  // DPI_DSClass, having type string\r\n  DSClass = 'dsClass',\r\n\r\n  // DPI_DatabaseName, having type string\r\n  DatabaseName = 'datasourceDatabaseName',\r\n\r\n  // DPI_DatabaseNote, having type string\r\n  DatabaseNote = 'databaseNote',\r\n\r\n  // DPI_DragLabel, having type string\r\n  DragLabel = 'dragLabel',\r\n\r\n  // DPI_EffectiveDateRange, having type string\r\n  EffectiveDateRange = 'effectiveDateRange',\r\n\r\n  // DPI_GoogleSheetCreatedTime, having type string\r\n  GoogleSheetCreatedTime = 'googleSheetCreatedTime',\r\n\r\n  // DPI_GoogleSheetId, having type string\r\n  GoogleSheetId = 'googleSheetId',\r\n\r\n  // DPI_GoogleSheetLastModifiedTime, having type string\r\n  GoogleSheetLastModifiedTime = 'googleSheetLastModifiedTime',\r\n\r\n  // DPI_GoogleSheetLastModifyingUser, having type string\r\n  GoogleSheetLastModifyingUser = 'googleSheetLastModifyingUser',\r\n\r\n  // DPI_GoogleSheetLastViewedByUserTime, having type string\r\n  GoogleSheetLastViewedByUserTime = 'googleSheetLastViewedByUserTime',\r\n\r\n  // DPI_GoogleSheetMimeType, having type string\r\n  GoogleSheetMimeType = 'googleSheetMimeType',\r\n\r\n  // DPI_GoogleSheetName, having type string\r\n  GoogleSheetName = 'googleSheetName',\r\n\r\n  // DPI_GoogleSheetOwner, having type string\r\n  GoogleSheetOwner = 'googleSheetOwner',\r\n\r\n  // DPI_GoogleSheetThumbnailLink, having type string\r\n  GoogleSheetThumbnailLink = 'googleSheetThumbnailLink',\r\n\r\n  // DPI_GoogleSheetThumbnailId, having type string\r\n  GoogleSheetThumbnailId = 'googleSheetThumbnailId',\r\n\r\n  // DPI_GoogleSheetThumbnailLocalPath, having type string\r\n  GoogleSheetThumbnailLocalPath = 'googleSheetThumbnailLocalPath',\r\n\r\n  // DPI_GoogleSheetWebViewLink, having type string\r\n  GoogleSheetWebViewLink = 'googleSheetWebViewLink',\r\n\r\n  // DPI_GoogleSheetsListErrorMessage, having type string\r\n  GoogleSheetsListErrorMessage = 'googleSheetsListErrorMessage',\r\n\r\n  // DPI_InitialSQL, having type string\r\n  InitialSQL = 'initialSql',\r\n\r\n  // DPI_ISODate, having type string\r\n  ISODate = 'isoDate',\r\n\r\n  // DPI_ISOEndDate, having type string\r\n  ISOEndDate = 'isoEndDate',\r\n\r\n  // DPI_ISOStartDate, having type string\r\n  ISOStartDate = 'isoStartDate',\r\n\r\n  // DPI_IsolationLevel, having type string\r\n  IsolationLevel = 'datasourceIsolationLevel',\r\n\r\n  // DPI_ItemDescription, having type string\r\n  ItemDescription = 'itemDescription',\r\n\r\n  // DPI_ItemId, having type string\r\n  ItemId = 'itemId',\r\n\r\n  // DPI_KerberosHost, having type string\r\n  KerberosHost = 'datasourceKerberosHost',\r\n\r\n  // DPI_KerberosRealm, having type string\r\n  KerberosRealm = 'datasourceKerberosRealm',\r\n\r\n  // DPI_KerberosService, having type string\r\n  KerberosService = 'datasourceKerberosService',\r\n\r\n  // DPI_Name, having type string\r\n  Name = 'name',\r\n\r\n  // DPI_OptionId, having type string\r\n  OptionId = 'optionId',\r\n\r\n  // DPI_PartitioningButtonLabel, having type string\r\n  PartitioningButtonLabel = 'partitioningButtonLabel',\r\n\r\n  // DPI_PartitioningButtonTooltip, having type string\r\n  PartitioningButtonTooltip = 'partitioningButtonTooltip',\r\n\r\n  // DPI_PartitioningText, having type string\r\n  PartitioningText = 'queryPartitioningText',\r\n\r\n  // DPI_PdfStartPage, having type string\r\n  PdfStartPage = 'pdfStartPage',\r\n\r\n  // DPI_PdfEndPage, having type string\r\n  PdfEndPage = 'pdfEndPage',\r\n\r\n  // DPI_PortPrompt, having type string\r\n  PortPrompt = 'portPrompt',\r\n\r\n  // DPI_PromptText, having type string\r\n  PromptText = 'promptText',\r\n\r\n  // DPI_QueryBanding, having type string\r\n  QueryBanding = 'queryBanding',\r\n\r\n  // DPI_QueryText, having type string\r\n  QueryText = 'queryText',\r\n\r\n  // DPI_RecommendationUUID, having type string\r\n  RecommendationUUID = 'recommendationUuid',\r\n\r\n  // DPI_SQLQuery, having type string\r\n  SQLQuery = 'sqlQuery',\r\n\r\n  // DPI_SchemaComboFallbackText, having type string\r\n  SchemaComboFallbackText = 'schemaComboFallbackText',\r\n\r\n  // DPI_SchemaLabel, having type string\r\n  SchemaLabel = 'schemaLabel',\r\n\r\n  // DPI_SchemaMemberGlobalName, having type string\r\n  SchemaMemberGlobalName = 'schemaMemberGlobalName',\r\n\r\n  // DPI_SchemaName, having type string\r\n  SchemaName = 'datasourceSchemaName',\r\n\r\n  // DPI_ScriptText, having type string\r\n  ScriptText = 'scriptText',\r\n\r\n  // DPI_SecondaryWhiteList, having type string\r\n  SecondaryWhiteList = 'secondaryWhiteList',\r\n\r\n  // DPI_Server, having type string\r\n  Server = 'datasourceServer',\r\n\r\n  // DPI_ServerNamePrompt, having type string\r\n  ServerNamePrompt = 'serverNamePrompt',\r\n\r\n  // DPI_Service, having type string\r\n  Service = 'datasourceService',\r\n\r\n  // DPI_ServiceNamePrompt, having type string\r\n  ServiceNamePrompt = 'servicePrompt',\r\n\r\n  // DPI_SheetFormatting, having type string\r\n  SheetFormatting = 'sheetFormatting',\r\n\r\n  // DPI_SlowMetadataSearchTerm, having type string\r\n  SlowMetadataSearchTerm = 'slowMetadataSearchTerm',\r\n\r\n  // DPI_StandardConnectionName, having type string\r\n  StandardConnectionName = 'datasourceStandardConnectionName',\r\n\r\n  // DPI_StandardConnectionPlaceholderText, having type string\r\n  StandardConnectionPlaceholderText = 'standardConnectionPlaceholderText',\r\n\r\n  // DPI_StoredProcedureParameterTitle, having type string\r\n  StoredProcedureParameterTitle = 'storedProcedureParameterTitle',\r\n\r\n  // DPI_TableAlias, having type string\r\n  TableAlias = 'tableAlias',\r\n\r\n  // DPI_RightTableAlias, having type string\r\n  RightTableAlias = 'rightTableAlias',\r\n\r\n  // DPI_TableCaption, having type string\r\n  TableCaption = 'tableCaption',\r\n\r\n  // DPI_TableCollectionName, having type string\r\n  TableCollectionName = 'tableCollectionName',\r\n\r\n  // DPI_TablePlaceholderText, having type string\r\n  TablePlaceholderText = 'tablePlaceholderText',\r\n\r\n  // DPI_TableRanking, having type string\r\n  TableRanking = 'tableRanking',\r\n\r\n  // DPI_TableSortKey, having type string\r\n  TableSortKey = 'tableSortkey',\r\n\r\n  // DPI_TableTooltip, having type string\r\n  TableTooltip = 'tableTooltip',\r\n\r\n  // DPI_TableToReplace, having type string\r\n  TableToReplace = 'tableToReplace',\r\n\r\n  // DPI_TableWarningMessage, having type string\r\n  TableWarningMessage = 'tableWarningMessage',\r\n\r\n  // DPI_TableauServerDatasourceDescription, having type string\r\n  TableauServerDatasourceDescription = 'tableauServerDatasourceDescription',\r\n\r\n  // DPI_TableauServerDatasourceLastExtract, having type string\r\n  TableauServerDatasourceLastExtract = 'tableauServerDatasourceLastExtract',\r\n\r\n  // DPI_TableauServerDatasourceModified, having type string\r\n  TableauServerDatasourceModified = 'tableauServerDatasourceModified',\r\n\r\n  // DPI_TableauServerDatasourceOwner, having type string\r\n  TableauServerDatasourceOwner = 'tableauServerDatasourceOwner',\r\n\r\n  // DPI_TableauServerDatasourcePath, having type string\r\n  TableauServerDatasourcePath = 'tableauServerDatasourcePath',\r\n\r\n  // DPI_TableauServerFetchSearchQuery, having type string\r\n  TableauServerFetchSearchQuery = 'tableauServerFetchSearchQuery',\r\n\r\n  // DPI_TableauServerName, having type string\r\n  TableauServerName = 'tableauServerName',\r\n\r\n  // DPI_TableauServerProjectName, having type string\r\n  TableauServerProjectName = 'tableauServerProjectName',\r\n\r\n  // DPI_TableauServerUsername, having type string\r\n  TableauServerUsername = 'tableauServerUsername',\r\n\r\n  // DPI_TransportType, having type string\r\n  TransportType = 'transportType',\r\n\r\n  // DPI_WarehouseName, having type string\r\n  WarehouseName = 'datasourceWarehouseName',\r\n\r\n  // DPI_WorkgroupWorkbookName, having type string\r\n  WorkgroupWorkbookName = 'workgroupWorkbookName',\r\n\r\n  // DPI_AnalyticsItemTooltip, having type string\r\n  AnalyticsItemTooltip = 'analyticsItemTooltip',\r\n\r\n  // DPI_Description, having type string\r\n  Description = 'description',\r\n\r\n  // DPI_DSClassCaption, having type string\r\n  DSClassCaption = 'dsClassCaption',\r\n\r\n  // DPI_Formula, having type string\r\n  Formula = 'formula',\r\n\r\n  // DPI_MessageText, having type string\r\n  MessageText = 'messageText',\r\n\r\n  // DPI_Datasource, having type string\r\n  Datasource = 'datasource',\r\n\r\n  // DPI_DatasourceSource, having type string\r\n  DatasourceSource = 'datasourceSource',\r\n\r\n  // DPI_DatasourceTarget, having type string\r\n  DatasourceTarget = 'datasourceTarget',\r\n\r\n  // DPI_FirstDatasource, having type string\r\n  FirstDatasource = 'firstDatasource',\r\n\r\n  // DPI_NewDatasource, having type string\r\n  NewDatasource = 'newDatasource',\r\n\r\n  // DPI_ParametersDatasource, having type string\r\n  ParametersDatasource = 'parametersDatasource',\r\n\r\n  // DPI_PrimaryDatasource, having type string\r\n  PrimaryDatasource = 'primaryDatasource',\r\n\r\n  // DPI_ConnectionDatabases, having type string[]\r\n  ConnectionDatabases = 'connectionDatabases',\r\n\r\n  // DPI_ConnectionSchemas, having type string[]\r\n  ConnectionSchemas = 'connectionSchemas',\r\n\r\n  // DPI_ConnectionWarehouses, having type string[]\r\n  ConnectionWarehouses = 'connectionWarehouses',\r\n\r\n  // DPI_DSClasses, having type string[]\r\n  DSClasses = 'dsClasses',\r\n\r\n  // DPI_PossibleChoices, having type string[]\r\n  PossibleChoices = 'possibleChoices',\r\n\r\n  // DPI_StandardConnections, having type string[]\r\n  StandardConnections = 'standardConnections',\r\n\r\n  // DPI_Strings, having type string[]\r\n  Strings = 'strings',\r\n\r\n  // DPI_TableauServerProjectNames, having type string[]\r\n  TableauServerProjectNames = 'tableauServerProjectNames',\r\n\r\n  // DPI_TableCaptions, having type string[]\r\n  TableCaptions = 'tableCaptions',\r\n\r\n  // DPI_DataValues, having type object[]\r\n  DataValues = 'dataValues',\r\n\r\n  // DPI_QueryBandErrors, having type object[]\r\n  QueryBandErrors = 'queryBandErrors',\r\n\r\n  // DPI_QueryBandParameters, having type object[]\r\n  QueryBandParameters = 'queryBandParameters',\r\n\r\n  // DPI_InitialSQLParameters, having type object[]\r\n  InitialSQLParameters = 'initialSqlParameters',\r\n\r\n  // DPI_ConnectionAttributes, having type Dictionary(of string)\r\n  ConnectionAttributes = 'connectionAttrs',\r\n\r\n  // DPI_ConnectionProps, having type Dictionary(of string)\r\n  ConnectionProps = 'connectionProps',\r\n\r\n  // DPI_DisplayNameMap, having type Dictionary(of string)\r\n  DisplayNameMap = 'displayNameMap',\r\n\r\n  // DPI_LookupTable, having type Dictionary(of string)\r\n  LookupTable = 'lookupTable',\r\n\r\n  // DPI_OAuthAttrs, having type Dictionary(of string)\r\n  OAuthAttrs = 'oauthAttrs',\r\n\r\n  // DPI_StringMap, having type Dictionary(of string)\r\n  StringMap = 'stringMap',\r\n\r\n  // DPI_TableRankingMap, having type Dictionary(of string)\r\n  TableRankingMap = 'tableRankingMap',\r\n\r\n  // DPI_WDCAttributes, having type Dictionary(of string)\r\n  WDCAttributes = 'wdcAttrs',\r\n\r\n  // DPI_ConnectorAttributes, having type Dictionary(of string)\r\n  ConnectorAttributes = 'connectorAttrs',\r\n\r\n  // DPI_TableRelevanceParams, having type Dictionary(of string)\r\n  TableRelevanceParams = 'tableRelevanceParams',\r\n\r\n  // DPI_ActualParameterParameter, having type string\r\n  ActualParameterParameter = 'actualParameterParameter',\r\n\r\n  // DPI_DataColumnName, having type string\r\n  DataColumnName = 'dataColumnName',\r\n\r\n  // DPI_LHSDataColumnName, having type string\r\n  LHSDataColumnName = 'lhsDataColumnName',\r\n\r\n  // DPI_RHSDataColumnName, having type string\r\n  RHSDataColumnName = 'rhsDataColumnName',\r\n\r\n  // DPI_FullCubeName, having type string\r\n  FullCubeName = 'fullCubeName',\r\n\r\n  // DPI_FullVariableName, having type string\r\n  FullVariableName = 'fullVariableName',\r\n\r\n  // DPI_SemanticRole, having type string\r\n  SemanticRole = 'semanticRole',\r\n\r\n  // DPI_StoredProcedureName, having type string\r\n  StoredProcedureName = 'storedProcName',\r\n\r\n  // DPI_TableName, having type string\r\n  TableName = 'tableName',\r\n\r\n  // DPI_AddedTableNames, having type string[]\r\n  AddedTableNames = 'addedTableNames',\r\n\r\n  // DPI_CoalesceGroupFields, having type string[]\r\n  CoalesceGroupFields = 'coalesceGroupFields',\r\n\r\n  // DPI_QualifiedNames, having type string[]\r\n  QualifiedNames = 'qualifiedNames',\r\n\r\n  // DPI_JoinFieldAliases, having type string[]\r\n  JoinFieldAliases = 'joinField_aliases',\r\n\r\n  // DPI_JoinInfoFields, having type string[]\r\n  JoinInfoFields = 'joinInfoFields',\r\n\r\n  // DPI_PivotGroupFields, having type string[]\r\n  PivotGroupFields = 'pivotGroupFields',\r\n\r\n  // DPI_RemovedTableNames, having type string[]\r\n  RemovedTableNames = 'removedTableNames',\r\n\r\n  // DPI_StoredProcedures, having type string[]\r\n  StoredProcedures = 'storedProcedures',\r\n\r\n  // DPI_TableNames, having type string[]\r\n  TableNames = 'tableNames',\r\n\r\n  // DPI_ColumnName, having type string\r\n  ColumnName = 'columnName',\r\n\r\n  // DPI_FieldName, having type string\r\n  FieldName = 'fn',\r\n\r\n  // DPI_FieldNames, having type string[]\r\n  FieldNames = 'fieldNames',\r\n\r\n  // DPI_GoogleSheetThumbnailImage, having type string\r\n  GoogleSheetThumbnailImage = 'googleSheetThumbnailImage',\r\n\r\n  // DPI_AttrMDWPassword, having type string\r\n  AttrMDWPassword = 'widgetAttrMdwPassword',\r\n\r\n  // DPI_AttrPassword, having type string\r\n  AttrPassword = 'widgetAttrPassword',\r\n\r\n  // DPI_DatasourcePassword, having type string\r\n  DatasourcePassword = 'datasourcePassword',\r\n\r\n  // DPI_FederatedKeychain, having type string\r\n  FederatedKeychain = 'federatedKeychain',\r\n\r\n  // DPI_DataParameterID, having type string\r\n  DataParameterID = 'dataParamType',\r\n\r\n  // DPI_ConnectServerWidgetType, having type ConnectServerWidgetType\r\n  ConnectServerWidgetType = 'connectServerWidgetType',\r\n\r\n  // DPI_AuthenticationMode, having type Mode\r\n  AuthenticationMode = 'authMode',\r\n\r\n  // DPI_ReconnectAuthMode, having type ReconnectMode\r\n  ReconnectAuthMode = 'reconnectAuthMode',\r\n\r\n  // DPI_CurrentAuthOption, having type AuthOption\r\n  CurrentAuthOption = 'currAuthOption',\r\n\r\n  // DPI_AuthOptionList, having type AuthOption[]\r\n  AuthOptionList = 'authOptions',\r\n\r\n  // DPI_ConnectionSpecificationType, having type ConnectionSpecificationType\r\n  ConnectionSpecificationType = 'connectionSpecificationType',\r\n\r\n  // DPI_DataType, having type DataType\r\n  DataType = 'dataType',\r\n\r\n  // DPI_LHSDataType, having type DataType\r\n  LHSDataType = 'lhsDataType',\r\n\r\n  // DPI_RHSDataType, having type DataType\r\n  RHSDataType = 'rhsDataType',\r\n\r\n  // DPI_DefaultFieldRole, having type FieldRole\r\n  DefaultFieldRole = 'defaultFieldRole',\r\n\r\n  // DPI_FieldRole, having type FieldRole\r\n  FieldRole = 'fieldRole',\r\n\r\n  // DPI_DefaultFieldType, having type FieldType\r\n  DefaultFieldType = 'defaultFieldType',\r\n\r\n  // DPI_FieldType, having type FieldType\r\n  FieldType = 'fieldType',\r\n\r\n  // DPI_FieldTypeList, having type FieldType[]\r\n  FieldTypeList = 'fieldTypeList',\r\n\r\n  // DPI_FieldTypeListDetail, having type FieldType[]\r\n  FieldTypeListDetail = 'fieldTypeListDetail',\r\n\r\n  // DPI_AggType, having type AggType\r\n  AggType = 'aggregation',\r\n\r\n  // DPI_DefaultAggType, having type AggType\r\n  DefaultAggType = 'defaultAggregation',\r\n\r\n  // DPI_ForecastAgg, having type AggType\r\n  ForecastAgg = 'forecastSummarizeTo',\r\n\r\n  // DPI_ForecastAutoAgg, having type AggType\r\n  ForecastAutoAgg = 'forecastAutoSummarizeTo',\r\n\r\n  // DPI_ForecastAutoRangeUnits, having type AggType\r\n  ForecastAutoRangeUnits = 'forecastAutoRangeUnits',\r\n\r\n  // DPI_ForecastEndOfRangeUnits, having type AggType\r\n  ForecastEndOfRangeUnits = 'forecastEndOfRangeUnits',\r\n\r\n  // DPI_ForecastNextRangeUnits, having type AggType\r\n  ForecastNextRangeUnits = 'forecastNextRangeUnits',\r\n\r\n  // DPI_SourceAgg, having type AggType\r\n  SourceAgg = 'sourceAggregation',\r\n\r\n  // DPI_TargetAgg, having type AggType\r\n  TargetAgg = 'targetAggregation',\r\n\r\n  // DPI_AggregateByAggTypes, having type AggType[]\r\n  AggregateByAggTypes = 'aggregateByAggTypes',\r\n\r\n  // DPI_AggregationValues, having type AggType[]\r\n  AggregationValues = 'aggregationValues',\r\n\r\n  // DPI_SortAggValues, having type AggType[]\r\n  SortAggValues = 'sortAggValues',\r\n\r\n  // DPI_ColumnClass, having type ColumnClass\r\n  ColumnClass = 'columnClass',\r\n\r\n  // DPI_DatePeriodType, having type DatePeriodType\r\n  DatePeriodType = 'datePeriodType',\r\n\r\n  // DPI_ConnectionWidgetType, having type ConnectionWidgetType\r\n  ConnectionWidgetType = 'connectionWidgetType',\r\n\r\n  // DPI_TablePillIcon, having type TablePillIcon\r\n  TablePillIcon = 'tablePillIconType',\r\n\r\n  // DPI_EnumeratedEntityType, having type EntityType\r\n  EnumeratedEntityType = 'enumeratedEntityType',\r\n\r\n  // DPI_PickEntitySearchType, having type PickEntitySearchType\r\n  PickEntitySearchType = 'entitySearchType',\r\n\r\n  // DPI_ExpressionOp, having type Op\r\n  ExpressionOp = 'expressionOp',\r\n\r\n  // DPI_ExpressionOperatorCaption, having type ExpressionOperatorCaptionPresModel\r\n  ExpressionOperatorCaption = 'expressionOperatorCaption',\r\n\r\n  // DPI_RelationalExperessionOps, having type ExpressionOperatorCaptionPresModel[]\r\n  RelationalExperessionOps = 'relationalExpressionOps',\r\n\r\n  // DPI_HierarchyExpressionOps, having type ExpressionOperatorCaptionPresModel[]\r\n  HierarchyExpressionOps = 'hierarchyExpressionOps',\r\n\r\n  // DPI_DefaultSortDirection, having type SortDirection\r\n  DefaultSortDirection = 'defSortOrder',\r\n\r\n  // DPI_SortDirection, having type SortDirection\r\n  SortDirection = 'sortOrder',\r\n\r\n  // DPI_SortDirectionValues, having type SortDirection[]\r\n  SortDirectionValues = 'sortDirectionValues',\r\n\r\n  // DPI_CubeMetadataCategory, having type CubeMetadataCategory\r\n  CubeMetadataCategory = 'cubeMetadataCategory',\r\n\r\n  // DPI_CubeMetadataCategories, having type CubeMetadataCategory[]\r\n  CubeMetadataCategories = 'cubeMetadataCategories',\r\n\r\n  // DPI_GoogleBasicInfoType, having type GoogleBasicInfoType\r\n  GoogleBasicInfoType = 'googleBasicInfoType',\r\n\r\n  // DPI_GoogleAnalyticsDateRangeOptionType, having type DateRange\r\n  GoogleAnalyticsDateRangeOptionType = 'googleAnalyticsDateRangeOptionType',\r\n\r\n  // DPI_TableCalcType, having type TableCalcType\r\n  TableCalcType = 'tableCalcType',\r\n\r\n  // DPI_TableCalcTypeValues, having type TableCalcType[]\r\n  TableCalcTypeValues = 'tableCalcTypeValues',\r\n\r\n  // DPI_RelativeAddress, having type RelativeAddress\r\n  RelativeAddress = 'relativeAddress',\r\n\r\n  // DPI_RelativeValues, having type RelativeAddress[]\r\n  RelativeValues = 'relativeValues',\r\n\r\n  // DPI_OrderingType, having type OrderingType\r\n  OrderingType = 'orderingType',\r\n\r\n  // DPI_OrderingTypeValues, having type OrderingType[]\r\n  OrderingTypeValues = 'orderingTypeValues',\r\n\r\n  // DPI_CategoricalBinItemType, having type CategoricalBinItemType\r\n  CategoricalBinItemType = 'categoricalBinItemType',\r\n\r\n  // DPI_AuthenticationInfos, having type AuthenticationSettingsPresModel\r\n  AuthenticationInfos = 'authInfo',\r\n\r\n  // DPI_ConnectionWidgetParams, having type ConnectionParamsPresModel\r\n  ConnectionWidgetParams = 'widgetConnectionParams',\r\n\r\n  // DPI_ConnectionSettings, having type ConnectionSettingsPresModel\r\n  ConnectionSettings = 'connectionSettings',\r\n\r\n  // DPI_ReconnectAuthenticationSettings, having type AuthenticationSettingsPresModel\r\n  ReconnectAuthenticationSettings = 'reconnectAuthSettings',\r\n\r\n  // DPI_CubeConnectionSpecificationOption, having type CubeConnectionSpecificationOptionPresModel\r\n  CubeConnectionSpecificationOption = 'cubeConnectionSpecificationOption',\r\n\r\n  // DPI_CubeConnectionSpecificationOptions, having type CubeConnectionSpecificationOptionPresModel[]\r\n  CubeConnectionSpecificationOptions = 'cubeConnectionSpecificationOptions',\r\n\r\n  // DPI_CubeConnectionSpecification, having type CubeConnectionSpecificationPresModel\r\n  CubeConnectionSpecification = 'cubeConnectionSpecification',\r\n\r\n  // DPI_ConnectionSettingsOption, having type ConnectionSettingsOptionPresModel\r\n  ConnectionSettingsOption = 'connectionSettingsOption',\r\n\r\n  // DPI_ConnectionSettingsOptions, having type ConnectionSettingsOptionPresModel[]\r\n  ConnectionSettingsOptions = 'connectionSettingsOptions',\r\n\r\n  // DPI_StringCollation, having type StringCollationPresModel\r\n  StringCollation = 'stringCollation',\r\n\r\n  // DPI_DatabaseEnumeration, having type DatabaseEnumerationPresModel\r\n  DatabaseEnumeration = 'databaseEnumeration',\r\n\r\n  // DPI_SchemaEnumeration, having type SchemaEnumerationPresModel\r\n  SchemaEnumeration = 'schemaEnumeration',\r\n\r\n  // DPI_StandardConnectionEnumeration, having type StandardConnectionEnumerationPresModel\r\n  StandardConnectionEnumeration = 'standardConnectionEnumeration',\r\n\r\n  // DPI_StoredProcedureEnumeration, having type StoredProcedureEnumerationPresModel\r\n  StoredProcedureEnumeration = 'storedProcedureEnumeration',\r\n\r\n  // DPI_TableEnumeration, having type TableEnumerationPresModel\r\n  TableEnumeration = 'tableEnumeration',\r\n\r\n  // DPI_WarehouseEnumeration, having type WarehouseEnumerationPresModel\r\n  WarehouseEnumeration = 'warehouseEnumeration',\r\n\r\n  // DPI_SlowMetadataSchemaList, having type SlowMetadataSchemaListPresModel\r\n  SlowMetadataSchemaList = 'slowMetadataSchemaList',\r\n\r\n  // DPI_SlowMetadataTableList, having type SlowMetadataTableListPresModel\r\n  SlowMetadataTableList = 'slowMetadataTableList',\r\n\r\n  // DPI_CubeCatalog, having type CubeCatalogPresModel\r\n  CubeCatalog = 'cubeCatalog',\r\n\r\n  // DPI_CubeCatalogs, having type CubeCatalogPresModel[]\r\n  CubeCatalogs = 'cubeCatalogs',\r\n\r\n  // DPI_CubeCatalogEnumeration, having type CubeCatalogEnumerationPresModel\r\n  CubeCatalogEnumeration = 'cubeCatalogEnumeration',\r\n\r\n  // DPI_Cube, having type CubePresModel\r\n  Cube = 'cube',\r\n\r\n  // DPI_Cubes, having type CubePresModel[]\r\n  Cubes = 'cubes',\r\n\r\n  // DPI_CubeEnumeration, having type CubeEnumerationPresModel\r\n  CubeEnumeration = 'cubeEnumeration',\r\n\r\n  // DPI_GoogleAnalyticsBasicItem, having type GoogleAnalyticsBasicItemPresModel\r\n  GoogleAnalyticsBasicItem = 'googleAnalyticsBasicItem',\r\n\r\n  // DPI_GAMeasureSets, having type GoogleAnalyticsBasicItemPresModel[]\r\n  GAMeasureSets = 'gaMeasureSets',\r\n\r\n  // DPI_GoogleAnalyticsViews, having type GoogleAnalyticsBasicItemPresModel[]\r\n  GoogleAnalyticsViews = 'googleAnalyticsViews',\r\n\r\n  // DPI_GoogleAnalyticsProperties, having type GoogleAnalyticsBasicItemPresModel[]\r\n  GoogleAnalyticsProperties = 'googleAnalyticsProperties',\r\n\r\n  // DPI_GoogleBasicInfoItems, having type GoogleAnalyticsBasicItemPresModel[]\r\n  GoogleBasicInfoItems = 'googleAnalyticsAccounts',\r\n\r\n  // DPI_GoogleAnalyticsComplexItem, having type GoogleAnalyticsComplexItemPresModel\r\n  GoogleAnalyticsComplexItem = 'googleAnalyticsComplexItem',\r\n\r\n  // DPI_GoogleAnalyticsPossibleDimensions, having type GoogleAnalyticsComplexItemPresModel[]\r\n  GoogleAnalyticsPossibleDimensions = 'googleAnalyticsPossibleDimensions',\r\n\r\n  // DPI_GoogleAnalyticsPossibleMeasures, having type GoogleAnalyticsComplexItemPresModel[]\r\n  GoogleAnalyticsPossibleMeasures = 'googleAnalyticsPossibleMeasures',\r\n\r\n  // DPI_GoogleAnalyticsPossibleSegments, having type GoogleAnalyticsComplexItemPresModel[]\r\n  GoogleAnalyticsPossibleSegments = 'googleAnalyticsPossibleSegments',\r\n\r\n  // DPI_GoogleAnalyticsSelectedDimensions, having type GoogleAnalyticsComplexItemPresModel[]\r\n  GoogleAnalyticsSelectedDimensions = 'googleAnalyticsSelectedDimensions',\r\n\r\n  // DPI_GoogleAnalyticsSelectedMeasures, having type GoogleAnalyticsComplexItemPresModel[]\r\n  GoogleAnalyticsSelectedMeasures = 'googleAnalyticsSelectedMeasures',\r\n\r\n  // DPI_GoogleAnalyticsDateRangeOption, having type GoogleAnalyticsDateRangeOptionPresModel\r\n  GoogleAnalyticsDateRangeOption = 'googleAnalyticsDateRangeOption',\r\n\r\n  // DPI_GoogleAnalyticsDateRangeOptions, having type GoogleAnalyticsDateRangeOptionPresModel[]\r\n  GoogleAnalyticsDateRangeOptions = 'googleAnalyticsDateRangeOptions',\r\n\r\n  // DPI_GoogleAnalyticsEndDate, having type GoogleAnalyticsDatePresModel\r\n  GoogleAnalyticsEndDate = 'googleAnalyticsEndDate',\r\n\r\n  // DPI_GoogleAnalyticsStartDate, having type GoogleAnalyticsDatePresModel\r\n  GoogleAnalyticsStartDate = 'googleAnalyticsStartDate',\r\n\r\n  // DPI_GoogleAnalyticsDateRange, having type GoogleAnalyticsDateRangePresModel\r\n  GoogleAnalyticsDateRange = 'googleAnalyticsDateRange',\r\n\r\n  // DPI_GoogleAnalyticsQueryPartitioning, having type GoogleAnalyticsQueryPartitioningPresModel\r\n  GoogleAnalyticsQueryPartitioning = 'googleAnalyticsQueryPartitioning',\r\n\r\n  // DPI_GAConnectionDescription, having type GoogleAnalyticsConnectionDescriptionPresModel\r\n  GAConnectionDescription = 'gaConnectionDescription',\r\n\r\n  // DPI_GoogleSheetItem, having type GoogleSheetItemPresModel\r\n  GoogleSheetItem = 'googleSheetItem',\r\n\r\n  // DPI_GoogleSheetItems, having type GoogleSheetItemPresModel[]\r\n  GoogleSheetItems = 'googleSheetItems',\r\n\r\n  // DPI_GoogleSheetsListPresModel, having type GoogleSheetsListPresModel\r\n  GoogleSheetsListPresModel = 'googleSheetsList',\r\n\r\n  // DPI_GoogleSheetPanePresModel, having type GoogleSheetPanePresModel\r\n  GoogleSheetPanePresModel = 'googleSheetPane',\r\n\r\n  // DPI_TableauServerConnectionDescription, having type TableauServerConnectionDescriptionPresModel\r\n  TableauServerConnectionDescription = 'tableauServerConnectionDescription',\r\n\r\n  // DPI_InitialSQLPresModel, having type InitialSQLPresModel\r\n  InitialSQLPresModel = 'initialSqlPresModel',\r\n\r\n  // DPI_QueryBandingPresModel, having type QueryBandingPresModel\r\n  QueryBandingPresModel = 'queryBandingPresModel',\r\n\r\n  // DPI_SlowMetadata, having type SlowMetadataPresModel\r\n  SlowMetadata = 'slowMetadata',\r\n\r\n  // DPI_SlowMetadataSchemaSearchPresModel, having type SlowMetadataSearchPresModel\r\n  SlowMetadataSchemaSearchPresModel = 'slowMetadataSchemaSearch',\r\n\r\n  // DPI_SlowMetadataTableSearchPresModel, having type SlowMetadataSearchPresModel\r\n  SlowMetadataTableSearchPresModel = 'slowMetadataTableSearch',\r\n\r\n  // DPI_TableauServerProjectsPresModel, having type TableauServerProjectsPresModel\r\n  TableauServerProjectsPresModel = 'tableauServerProjectsPresmodel',\r\n\r\n  // DPI_TableauServerDataSourcePresModel, having type TableauServerDataSourcePresModel\r\n  TableauServerDataSourcePresModel = 'tableauServerDataSourcePresmodel',\r\n\r\n  // DPI_TableauServerDataSourcePresModels, having type TableauServerDataSourcePresModel[]\r\n  TableauServerDataSourcePresModels = 'tableauServerDataSourcePresmodels',\r\n\r\n  // DPI_TableauServerDataSourcesPresModel, having type TableauServerDataSourcesPresModel\r\n  TableauServerDataSourcesPresModel = 'tableauServerDataSourcesPresmodel',\r\n\r\n  // DPI_TableauServerDataPresModel, having type TableauServerDataPresModel\r\n  TableauServerDataPresModel = 'tableauServerDataPresmodel',\r\n\r\n  // DPI_StoredProcedureParameterPresModel, having type StoredProcedureParameterPresModel\r\n  StoredProcedureParameterPresModel = 'storedProcedureParameter',\r\n\r\n  // DPI_StoredProcedureParametersPresModel, having type StoredProcedureParameterPresModel[]\r\n  StoredProcedureParametersPresModel = 'storedProcedureParameters',\r\n\r\n  // DPI_CustomSQLInfo, having type CustomSQLInfoPresModel\r\n  CustomSQLInfo = 'customSqlInfo',\r\n\r\n  // DPI_ConnectionTableInfo, having type ConnectionTableInfoPresModel\r\n  ConnectionTableInfo = 'connectionTableInfo',\r\n\r\n  // DPI_TableInfos, having type ConnectionTableInfoPresModel[]\r\n  TableInfos = 'tableInfos',\r\n\r\n  // DPI_ConnectionDescription, having type ConnectionDescriptionPresModel\r\n  ConnectionDescription = 'connectionDescription',\r\n\r\n  // DPI_ConnectionDescriptionSummary, having type ConnectionDescriptionSummaryPresModel\r\n  ConnectionDescriptionSummary = 'connectionDescriptionSummary',\r\n\r\n  // DPI_ConnectionDescriptionSummaries, having type ConnectionDescriptionSummaryPresModel[]\r\n  ConnectionDescriptionSummaries = 'connectionDescriptionSummaries',\r\n\r\n  // DPI_DataSourceParserValidationMode, having type DataSourceParserValidationMode\r\n  DataSourceParserValidationMode = 'dataSourceParserValidationMode',\r\n\r\n  // DPI_OAuthCredentialTypeInfo, having type OAuthCredentialTypeInfoPresModel\r\n  OAuthCredentialTypeInfo = 'oauthCredentialTypeInfo',\r\n\r\n  // DPI_OAuthCredentialTypeInfos, having type OAuthCredentialTypeInfoPresModel[]\r\n  OAuthCredentialTypeInfos = 'oauthCredentialTypeInfos',\r\n\r\n  // DPI_OAuthSettings, having type OAuthSettingsPresModel\r\n  OAuthSettings = 'oauthSettings',\r\n\r\n  // DPI_CredentialTypePropertiesFlag, having type CredentialTypePropertiesFlag\r\n  CredentialTypePropertiesFlag = 'credentialTypePropertiesFlag',\r\n\r\n  // DPI_CredentialTypePropertiesFlags, having type CredentialTypePropertiesFlag[]\r\n  CredentialTypePropertiesFlags = 'credentialTypePropertiesFlags',\r\n\r\n  // DPI_ConnectionTypeEnum, having type ConnectionTypeEnum\r\n  ConnectionTypeEnum = 'connectionTypeEnum',\r\n\r\n  // DPI_ConnectorType, having type ConnectorType\r\n  ConnectorType = 'connectorType',\r\n\r\n  // DPI_PdfPagePicker, having type PdfPagePickerPresModel\r\n  PdfPagePicker = 'pdfPagePicker',\r\n\r\n  // DPI_ActivateNew, having type bool\r\n  ActivateNew = 'activateNew',\r\n\r\n  // DPI_AddActions, having type bool\r\n  AddActions = 'addActions',\r\n\r\n  // DPI_AddAsFloating, having type bool\r\n  AddAsFloating = 'addAsFloating',\r\n\r\n  // DPI_AddColorDictionary, having type bool\r\n  AddColorDictionary = 'addColorDictionary',\r\n\r\n  // DPI_AddDroplines, having type bool\r\n  AddDroplines = 'addDroplines',\r\n\r\n  // DPI_AddHeaders, having type bool\r\n  AddHeaders = 'addHeaders',\r\n\r\n  // DPI_AddHighlighting, having type bool\r\n  AddHighlighting = 'addHighlighting',\r\n\r\n  // DPI_AddImageDictionary, having type bool\r\n  AddImageDictionary = 'addImageDictionary',\r\n\r\n  // DPI_AddMarkLabels, having type bool\r\n  AddMarkLabels = 'addMarkLabels',\r\n\r\n  // DPI_AddPages, having type bool\r\n  AddPages = 'addPages',\r\n\r\n  // DPI_AddSelection, having type bool\r\n  AddSelection = 'addSelection',\r\n\r\n  // DPI_AddToFolder, having type bool\r\n  AddToFolder = 'addToFolder',\r\n\r\n  // DPI_AddVizData, having type bool\r\n  AddVizData = 'addVizData',\r\n\r\n  // DPI_AlertConditionMet, having type bool\r\n  AlertConditionMet = 'alertConditionMet',\r\n\r\n  // DPI_AllFields, having type bool\r\n  AllFields = 'allFields',\r\n\r\n  // DPI_AllOnEmpty, having type bool\r\n  AllOnEmpty = 'allOnEmpty',\r\n\r\n  // DPI_AllPages, having type bool\r\n  AllPages = 'includeAllPages',\r\n\r\n  // DPI_AllowPreviewSizeChange, having type bool\r\n  AllowPreviewSizeChange = 'allowPreviewSizeChange',\r\n\r\n  // DPI_AllSelectedIsEffectivelyRangeTypeAll, having type bool\r\n  AllSelectedIsEffectivelyRangeTypeAll = 'allSelectedIsEffectivelyRangeTypeAll',\r\n\r\n  // DPI_AllStoryPoints, having type bool\r\n  AllStoryPoints = 'allStorypoints',\r\n\r\n  // DPI_AllowAllRange, having type bool\r\n  AllowAllRange = 'allowAllRange',\r\n\r\n  // DPI_AllowCreatingNewParameters, having type bool\r\n  AllowCreatingNewParameters = 'allowCreatingNewParameters',\r\n\r\n  // DPI_AllowContinuousDate, having type bool\r\n  AllowContinuousDate = 'allowContinuousDate',\r\n\r\n  // DPI_AllowDuplicateFieldDropOnFilterShelf, having type bool\r\n  AllowDuplicateFieldDropOnFilterShelf = 'allowDuplicateFieldDropOnFilterShelf',\r\n\r\n  // DPI_AllowFilterPreset, having type bool\r\n  AllowFilterPreset = 'allowFilterPreset',\r\n\r\n  // DPI_AllowHoverActions, having type bool\r\n  AllowHoverActions = 'allowHoverActions',\r\n\r\n  // DPI_AllowHyphenation, having type bool\r\n  AllowHyphenation = 'allowHyphenation',\r\n\r\n  // DPI_AllowJoinOnCalc, having type bool\r\n  AllowJoinOnCalc = 'allowJoinOnCalc',\r\n\r\n  // DPI_AllowManualRange, having type bool\r\n  AllowManualRange = 'allowManualRange',\r\n\r\n  // DPI_AllowMapping, having type bool\r\n  AllowMapping = 'allowMapping',\r\n\r\n  // DPI_AllowMultiSelect, having type bool\r\n  AllowMultiSelect = 'allowMultiSelect',\r\n\r\n  // DPI_AllowNull, having type bool\r\n  AllowNull = 'allowNull',\r\n\r\n  // DPI_AllowPanZoom, having type bool\r\n  AllowPanZoom = 'allowPanZoom',\r\n\r\n  // DPI_AllowPatternBased, having type bool\r\n  AllowPatternBased = 'allowPatternBasedUnion',\r\n\r\n  // DPI_AllowPromptText, having type bool\r\n  AllowPromptText = 'allowPromptText',\r\n\r\n  // DPI_AllowSaveDataSource, having type bool\r\n  AllowSaveDataSource = 'allowSaveDataSource',\r\n\r\n  // DPI_AllowWholeDate, having type bool\r\n  AllowWholeDate = 'allowWholeDate',\r\n\r\n  // DPI_AllowWork, having type bool\r\n  AllowWork = 'allowWork',\r\n\r\n  // DPI_AllowWrap, having type bool\r\n  AllowWrap = 'allowWrap',\r\n\r\n  // DPI_AppIs32Bit, having type bool\r\n  AppIs32Bit = 'appIs32Bit',\r\n\r\n  // DPI_AppIs64Bit, having type bool\r\n  AppIs64Bit = 'appIs64Bit',\r\n\r\n  // DPI_AppIsBeta, having type bool\r\n  AppIsBeta = 'appIsBeta',\r\n\r\n  // DPI_AppIsOEM, having type bool\r\n  AppIsOEM = 'appIsOem',\r\n\r\n  // DPI_AppendTde, having type bool\r\n  AppendTde = 'appendTde',\r\n\r\n  // DPI_ApplyColors, having type bool\r\n  ApplyColors = 'applyColors',\r\n\r\n  // DPI_ApplyNewSelection, having type bool\r\n  ApplyNewSelection = 'applyNewSelection',\r\n\r\n  // DPI_AreConfidenceBandsValid, having type bool\r\n  AreConfidenceBandsValid = 'areConfidenceBandsValid',\r\n\r\n  // DPI_AreDataSourceFiltersVisible, having type bool\r\n  AreDataSourceFiltersVisible = 'areDataSourceFiltersVisible',\r\n\r\n  // DPI_AreExtractFiltersEnabled, having type bool\r\n  AreExtractFiltersEnabled = 'areExtractFiltersEnabled',\r\n\r\n  // DPI_AreTotalsUsed, having type bool\r\n  AreTotalsUsed = 'areTotalsUsed',\r\n\r\n  // DPI_AtTheLevelFieldIsInvalid, having type bool\r\n  AtTheLevelFieldIsInvalid = 'atTheLevelFieldIsInvalid',\r\n\r\n  // DPI_AutoURL, having type bool\r\n  AutoURL = 'autoUrl',\r\n\r\n  // DPI_AutoUpdate, having type bool\r\n  AutoUpdate = 'autoUpdate',\r\n\r\n  // DPI_BackingSheetIsDashboard, having type bool\r\n  BackingSheetIsDashboard = 'isBackingSheetDashboard',\r\n\r\n  // DPI_BeginDataSourcePresModelUpdate, having type bool\r\n  BeginDataSourcePresModelUpdate = 'beginDataSourcePresModelUpdate',\r\n\r\n  // DPI_AggregateDrillUp, having type bool\r\n  AggregateDrillUp = 'boolAggregateDrillUp',\r\n\r\n  // DPI_BoxplotMarkExclusion, having type bool\r\n  BoxplotMarkExclusion = 'boxplotMarkExclusion',\r\n\r\n  // DPI_BreakPageOnPane, having type bool\r\n  BreakPageOnPane = 'breakPageOnPane',\r\n\r\n  // DPI_BrushLegends, having type bool\r\n  BrushLegends = 'brushLegends',\r\n\r\n  // DPI_CachePresModels, having type bool\r\n  CachePresModels = 'cachePresModels',\r\n\r\n  // DPI_CanAddConnections, having type bool\r\n  CanAddConnections = 'canAddConnections',\r\n\r\n  // DPI_SortPillCanBeDragged, having type bool\r\n  SortPillCanBeDragged = 'sortPillCanBeDragged',\r\n\r\n  // DPI_CanAddTable, having type bool\r\n  CanAddTable = 'canAddTable',\r\n\r\n  // DPI_CanAddToDrillPath, having type bool\r\n  CanAddToDrillPath = 'canAddToDrillPath',\r\n\r\n  // DPI_CanAnalyzeData, having type bool\r\n  CanAnalyzeData = 'canAnalyzeData',\r\n\r\n  // DPI_CanChangeDataType, having type bool\r\n  CanChangeDataType = 'canChangeDataType',\r\n\r\n  // DPI_CanChangeSemanticRole, having type bool\r\n  CanChangeSemanticRole = 'canChangeSemanticRole',\r\n\r\n  // DPI_CanDerive, having type bool\r\n  CanDerive = 'canDerive',\r\n\r\n  // DPI_CanDrop, having type bool\r\n  CanDrop = 'canDrop',\r\n\r\n  // DPI_CanEdit, having type bool\r\n  CanEdit = 'canEdit',\r\n\r\n  // DPI_CanEditLegendColor, having type bool\r\n  CanEditLegendColor = 'canEditLegendColor',\r\n\r\n  // DPI_CanEnableCenter, having type bool\r\n  CanEnableCenter = 'canEnableCenter',\r\n\r\n  // DPI_CanShowAdvancedSettings, having type bool\r\n  CanShowAdvancedSettings = 'canShowAdvancedSettings',\r\n\r\n  // DPI_CanEnableFilterStateButton, having type bool\r\n  CanEnableFilterStateButton = 'canEnableFilterStateButton',\r\n\r\n  // DPI_CanFloat, having type bool\r\n  CanFloat = 'canFloat',\r\n\r\n  // DPI_CanHaveTitle, having type bool\r\n  CanHaveTitle = 'canHaveTitle',\r\n\r\n  // DPI_CanIgnoreUpdate, having type bool\r\n  CanIgnoreUpdate = 'canIgnoreUpdate',\r\n\r\n  // DPI_CanLogTransformExplanatoryAxis, having type bool\r\n  CanLogTransformExplanatoryAxis = 'canLogTransformExplanatoryAxis',\r\n\r\n  // DPI_CanNavigateBack, having type bool\r\n  CanNavigateBack = 'canNavigateBack',\r\n\r\n  // DPI_CanNavigateForward, having type bool\r\n  CanNavigateForward = 'canNavigateForward',\r\n\r\n  // DPI_CanScrollX, having type bool\r\n  CanScrollX = 'canScrollX',\r\n\r\n  // DPI_CanScrollY, having type bool\r\n  CanScrollY = 'canScrollY',\r\n\r\n  // DPI_CanSetDomain, having type bool\r\n  CanSetDomain = 'canSetDomain',\r\n\r\n  // DPI_CanSetMapUnit, having type bool\r\n  CanSetMapUnit = 'canSetMapUnit',\r\n\r\n  // DPI_CanShowApplyButton, having type bool\r\n  CanShowApplyButton = 'canShowApplyButton',\r\n\r\n  // DPI_CanShowFilterStateButton, having type bool\r\n  CanShowFilterStateButton = 'canShowFilterStateButton',\r\n\r\n  // DPI_CanShowMoreFewerButton, having type bool\r\n  CanShowMoreFewerButton = 'canShowMoreFewerButton',\r\n\r\n  // DPI_CanShowSyncClientOptions, having type bool\r\n  CanShowSyncClientOptions = 'canShowSyncClientOptions',\r\n\r\n  // DPI_CanSort, having type bool\r\n  CanSort = 'canSort',\r\n\r\n  // DPI_CanSortOrdinally, having type bool\r\n  CanSortOrdinally = 'canSortOrdinal',\r\n\r\n  // DPI_CanToggleAutomaticDrill, having type bool\r\n  CanToggleAutomaticDrill = 'canToggleAutomaticDrill',\r\n\r\n  // DPI_CanToggleGeographicSearch, having type bool\r\n  CanToggleGeographicSearch = 'canToggleGeographicSearch',\r\n\r\n  // DPI_CanToggleMapScale, having type bool\r\n  CanToggleMapScale = 'canToggleMapScale',\r\n\r\n  // DPI_CanUseFullColorRange, having type bool\r\n  CanUseFullColorRange = 'canUseFullColorRange',\r\n\r\n  // DPI_CanUseMultipleHierarchies, having type bool\r\n  CanUseMultipleHierarchies = 'canUseMultipleHierarchies',\r\n\r\n  // DPI_CenterHorizontally, having type bool\r\n  CenterHorizontally = 'centerHorizontally',\r\n\r\n  // DPI_CenterVertically, having type bool\r\n  CenterVertically = 'centerVertically',\r\n\r\n  // DPI_ChangeAllFields, having type bool\r\n  ChangeAllFields = 'changeAllFields',\r\n\r\n  // DPI_Changed, having type bool\r\n  Changed = 'changed',\r\n\r\n  // DPI_ClearBrushing, having type bool\r\n  ClearBrushing = 'clearBrushing',\r\n\r\n  // DPI_ClearSort, having type bool\r\n  ClearSort = 'clearSort',\r\n\r\n  // DPI_ClearView, having type bool\r\n  ClearView = 'clearView',\r\n\r\n  // DPI_Collapsed, having type bool\r\n  Collapsed = 'collapsed',\r\n\r\n  // DPI_ConsolidateInCommit, having type bool\r\n  ConsolidateInCommit = 'consolidateInCommit',\r\n\r\n  // DPI_ClusterEnableScaledCheckbox, having type bool\r\n  ClusterEnableScaledCheckbox = 'clusterEnableScaledCheckbox',\r\n\r\n  // DPI_CommitPillFinished, having type bool\r\n  CommitPillFinished = 'commitPillFinished',\r\n\r\n  // DPI_CompressArrays, having type bool\r\n  CompressArrays = 'compressArrays',\r\n\r\n  // DPI_ComputeCompoundedRate, having type bool\r\n  ComputeCompoundedRate = 'computeCompoundedRate',\r\n\r\n  // DPI_ConfidenceIntervalAllowed, having type bool\r\n  ConfidenceIntervalAllowed = 'confidenceIntervalAllowed',\r\n\r\n  // DPI_ConfigIsDesktopStandard, having type bool\r\n  ConfigIsDesktopStandard = 'configIsDesktopStandard',\r\n\r\n  // DPI_ConfigIsInteractor, having type bool\r\n  ConfigIsInteractor = 'configIsInteractor',\r\n\r\n  // DPI_ConfigIsPublic, having type bool\r\n  ConfigIsPublic = 'configIsPublic',\r\n\r\n  // DPI_ConfigIsReader, having type bool\r\n  ConfigIsReader = 'configIsReader',\r\n\r\n  // DPI_ContainsQuant, having type bool\r\n  ContainsQuant = 'containsQuant',\r\n\r\n  // DPI_ContainsValidDatasources, having type bool\r\n  ContainsValidDatasources = 'containsValidDatasources',\r\n\r\n  // DPI_ControllerMissing, having type bool\r\n  ControllerMissing = 'controllerMissing',\r\n\r\n  // DPI_CreateExtractForPublish, having type bool\r\n  CreateExtractForPublish = 'createExtractForPublish',\r\n\r\n  // DPI_CrossTab, having type bool\r\n  CrossTab = 'crossTab',\r\n\r\n  // DPI_CullLabels, having type bool\r\n  CullLabels = 'cullLabels',\r\n\r\n  // DPI_CurrentCustViewIdFlag, having type bool\r\n  CurrentCustViewIdFlag = 'isCurrentCustViewIdValid',\r\n\r\n  // DPI_DashboardEnableSnap, having type bool\r\n  DashboardEnableSnap = 'dashboardEnableSnap',\r\n\r\n  // DPI_DashboardShowGrid, having type bool\r\n  DashboardShowGrid = 'dashboardShowGrid',\r\n\r\n  // DPI_DataGridSortOrder, having type bool\r\n  DataGridSortOrder = 'datagridSortOrder',\r\n\r\n  // DPI_DeleteExtract, having type bool\r\n  DeleteExtract = 'deleteExtract',\r\n\r\n  // DPI_DeleteOnlySpecifiedSelection, having type bool\r\n  DeleteOnlySpecifiedSelection = 'deleteOnlySpecifiedSelection',\r\n\r\n  // DPI_DeleteOrphans, having type bool\r\n  DeleteOrphans = 'deleteOrphans',\r\n\r\n  // DPI_DimensionIsEffectivelyEmpty, having type bool\r\n  DimensionIsEffectivelyEmpty = 'dimensionIsEffectivelyEmpty',\r\n\r\n  // DPI_DisabledDataConnectionClassNames, having type bool\r\n  DisabledDataConnectionClassNames = 'disabledDataConnectionClassNames',\r\n\r\n  // DPI_DisablePresModelHandler, having type bool\r\n  DisablePresModelHandler = 'disablePresModelHandler',\r\n\r\n  // DPI_DisplayDate, having type bool\r\n  DisplayDate = 'displayDate',\r\n\r\n  // DPI_DisplayTime, having type bool\r\n  DisplayTime = 'displayTime',\r\n\r\n  // DPI_DoDropUIAction, having type bool\r\n  DoDropUIAction = 'doDropUiAction',\r\n\r\n  // DPI_DoMerge, having type bool\r\n  DoMerge = 'doMerge',\r\n\r\n  // DPI_DoPreDropUIAction, having type bool\r\n  DoPreDropUIAction = 'doPreDropUiAction',\r\n\r\n  // DPI_DoQuery, having type bool\r\n  DoQuery = 'doQuery',\r\n\r\n  // DPI_DragHorz, having type bool\r\n  DragHorz = 'dragHorz',\r\n\r\n  // DPI_DrillDown, having type bool\r\n  DrillDown = 'drillDown',\r\n\r\n  // DPI_DropToXAxis, having type bool\r\n  DropToXAxis = 'dropToXAxis',\r\n\r\n  // DPI_DropToYAxis, having type bool\r\n  DropToYAxis = 'dropToYAxis',\r\n\r\n  // DPI_DropUnnamedFields, having type bool\r\n  DropUnnamedFields = 'dropUnnamedFields',\r\n\r\n  // DPI_EditExisting, having type bool\r\n  EditExisting = 'editExisting',\r\n\r\n  // DPI_EditingConnection, having type bool\r\n  EditingConnection = 'editingConnection',\r\n\r\n  // DPI_EmbedCredentials, having type bool\r\n  EmbedCredentials = 'embedCredentials',\r\n\r\n  // DPI_EmbedOAuthCredential, having type bool\r\n  EmbedOAuthCredential = 'embedOauthCredentials',\r\n\r\n  // DPI_EmptyHighlightFogAll, having type bool\r\n  EmptyHighlightFogAll = 'emptyHighlightFogAll',\r\n\r\n  // DPI_EnableAlphabeticSort, having type bool\r\n  EnableAlphabeticSort = 'enableAlphabeticSort',\r\n\r\n  // DPI_EnableAutomaticDrill, having type bool\r\n  EnableAutomaticDrill = 'enableAutomaticDrill',\r\n\r\n  // DPI_EnableConfidenceBands, having type bool\r\n  EnableConfidenceBands = 'enableConfidenceBands',\r\n\r\n  // DPI_EnableDataOrderSort, having type bool\r\n  EnableDataOrderSort = 'enableDataOrderSort',\r\n\r\n  // DPI_EnableFieldSort, having type bool\r\n  EnableFieldSort = 'enableFieldSort',\r\n\r\n  // DPI_EnableInstantAnalytics, having type bool\r\n  EnableInstantAnalytics = 'enableInstantAnalytics',\r\n\r\n  // DPI_EnableLines, having type bool\r\n  EnableLines = 'enableLines',\r\n\r\n  // DPI_EnableManualSort, having type bool\r\n  EnableManualSort = 'enableManualSort',\r\n\r\n  // DPI_EnableMarks, having type bool\r\n  EnableMarks = 'enableMarks',\r\n\r\n  // DPI_EnableMultipleSelection, having type bool\r\n  EnableMultipleSelection = 'enableMultipleSelection',\r\n\r\n  // DPI_EnablePrefetching, having type bool\r\n  EnablePrefetching = 'enablePrefetching',\r\n\r\n  // DPI_EnableTableCalcDensification, having type bool\r\n  EnableTableCalcDensification = 'enableTableCalcDensification',\r\n\r\n  // DPI_EnableTooltips, having type bool\r\n  EnableTooltips = 'enableTooltips',\r\n\r\n  // DPI_EndDataSourcePresModelUpdate, having type bool\r\n  EndDataSourcePresModelUpdate = 'endDataSourcePresModelUpdate',\r\n\r\n  // DPI_EstimateNulls, having type bool\r\n  EstimateNulls = 'estimateNulls',\r\n\r\n  // DPI_Exclude, having type bool\r\n  Exclude = 'exclude',\r\n\r\n  // DPI_ExcludeColor, having type bool\r\n  ExcludeColor = 'excludeColor',\r\n\r\n  // DPI_ExcludeCubeDenorm, having type bool\r\n  ExcludeCubeDenorm = 'excludeCubeDenorm',\r\n\r\n  // DPI_ExcludeInterceptEnabled, having type bool\r\n  ExcludeInterceptEnabled = 'excludeInterceptEnabled',\r\n\r\n  // DPI_ExcludeLocalFunctions, having type bool\r\n  ExcludeLocalFunctions = 'excludeLocalFunctions',\r\n\r\n  // DPI_ExportDashboardImageFromSheet, having type bool\r\n  ExportDashboardImageFromSheet = 'exportImageSheetAsDashboard',\r\n\r\n  // DPI_ExtSvcConfigIsAuthEnabled, having type bool\r\n  ExtSvcConfigIsAuthEnabled = 'extSvcConfigIsAuthEnabled',\r\n\r\n  // DPI_ExtractFullRefresh, having type bool\r\n  ExtractFullRefresh = 'extractFullRefresh',\r\n\r\n  // DPI_ExtractNeedsRefresh, having type bool\r\n  ExtractNeedsRefresh = 'extractNeedsRefresh',\r\n\r\n  // DPI_ExtractPending, having type bool\r\n  ExtractPending = 'extractPending',\r\n\r\n  // DPI_ExtractSelected, having type bool\r\n  ExtractSelected = 'extractSelected',\r\n\r\n  // DPI_FederatableOnly, having type bool\r\n  FederatableOnly = 'federatableOnly',\r\n\r\n  // DPI_FieldSortOrder, having type bool\r\n  FieldSortOrder = 'fieldSortOrder',\r\n\r\n  // DPI_FieldSupportsContains, having type bool\r\n  FieldSupportsContains = 'fieldSupportsContains',\r\n\r\n  // DPI_FieldSupportsEndsWith, having type bool\r\n  FieldSupportsEndsWith = 'fieldSupportsEndsWith',\r\n\r\n  // DPI_FieldSupportsStartsWith, having type bool\r\n  FieldSupportsStartsWith = 'fieldSupportsStartsWith',\r\n\r\n  // DPI_FillAbove, having type bool\r\n  FillAbove = 'fillAbove',\r\n\r\n  // DPI_FillBelow, having type bool\r\n  FillBelow = 'fillBelow',\r\n\r\n  // DPI_FillWithZeroes, having type bool\r\n  FillWithZeroes = 'fillZeroes',\r\n\r\n  // DPI_FilterIsNamed, having type bool\r\n  FilterIsNamed = 'filterIsNamed',\r\n\r\n  // DPI_Focus, having type bool\r\n  Focus = 'focus',\r\n\r\n  // DPI_ForInternalUse, having type bool\r\n  ForInternalUse = 'internalUse',\r\n\r\n  // DPI_ForceBrowserRendering, having type bool\r\n  ForceBrowserRendering = 'forceBrowserRendering',\r\n\r\n  // DPI_ForceCache, having type bool\r\n  ForceCache = 'forceCache',\r\n\r\n  // DPI_ForceColorFromApp, having type bool\r\n  ForceColorFromApp = 'forceColorFromApp',\r\n\r\n  // DPI_ForceConnectionAttempt, having type bool\r\n  ForceConnectionAttempt = 'forceConnectionAttempt',\r\n\r\n  // DPI_ForceConsolidateInCommit, having type bool\r\n  ForceConsolidateInCommit = 'forceConsolidateInCommit',\r\n\r\n  // DPI_ForceExtractRefresh, having type bool\r\n  ForceExtractRefresh = 'extractForceRefresh',\r\n\r\n  // DPI_ForceInterceptZero, having type bool\r\n  ForceInterceptZero = 'forceInterceptZero',\r\n\r\n  // DPI_ForceOldConnectExperience, having type bool\r\n  ForceOldConnectExperience = 'forceOldConnectExperience',\r\n\r\n  // DPI_ForceRelativeDate, having type bool\r\n  ForceRelativeDate = 'forceRelativeDate',\r\n\r\n  // DPI_ForceToggleHighlightStateOn, having type bool\r\n  ForceToggleHighlightStateOn = 'forceHighlightOn',\r\n\r\n  // DPI_ForceUserToChoose, having type bool\r\n  ForceUserToChoose = 'forceUserToChoose',\r\n\r\n  // DPI_ForceWholeDate, having type bool\r\n  ForceWholeDate = 'forceWholeDate',\r\n\r\n  // DPI_ForecastSelected, having type bool\r\n  ForecastSelected = 'forecastSelected',\r\n\r\n  // DPI_ForecastUseAutoAgg, having type bool\r\n  ForecastUseAutoAgg = 'forecastUseAutoSummarize',\r\n\r\n  // DPI_ForJoin, having type bool\r\n  ForJoin = 'forJoin',\r\n\r\n  // DPI_FormatDataValueLocally, having type bool\r\n  FormatDataValueLocally = 'formatDataValueLocally',\r\n\r\n  // DPI_FormatIfColumn, having type bool\r\n  FormatIfColumn = 'formatIfColumn',\r\n\r\n  // DPI_FormatIfParameter, having type bool\r\n  FormatIfParameter = 'formatIfParameter',\r\n\r\n  // DPI_GeographicSearchIsDataLoaded, having type bool\r\n  GeographicSearchIsDataLoaded = 'geographicSearchDataLoaded',\r\n\r\n  // DPI_GeographicSearchLoadDataAsync, having type bool\r\n  GeographicSearchLoadDataAsync = 'geographicSearchLoadDataAsync',\r\n\r\n  // DPI_GroupByAll, having type bool\r\n  GroupByAll = 'groupByAll',\r\n\r\n  // DPI_HasAlias, having type bool\r\n  HasAlias = 'hasAlias',\r\n\r\n  // DPI_HasAllMember, having type bool\r\n  HasAllMember = 'hasAllMember',\r\n\r\n  // DPI_HasApply, having type bool\r\n  HasApply = 'hasApply',\r\n\r\n  // DPI_HasBackgroundImage, having type bool\r\n  HasBackgroundImage = 'hasBackgroundImage',\r\n\r\n  // DPI_HasBeenDismissed, having type bool\r\n  HasBeenDismissed = 'hasBeenDismissed',\r\n\r\n  // DPI_HasCaption, having type bool\r\n  HasCaption = 'hasCaption',\r\n\r\n  // DPI_HasCondition, having type bool\r\n  HasCondition = 'hasCondition',\r\n\r\n  // DPI_HasConnectPermissions, having type bool\r\n  HasConnectPermissions = 'hasConnectPermissions',\r\n\r\n  // DPI_HasDashboard, having type bool\r\n  HasDashboard = 'hasDashboard',\r\n\r\n  // DPI_HasDownloadPermissions, having type bool\r\n  HasDownloadPermissions = 'hasDownloadPermissions',\r\n\r\n  // DPI_HasDrill, having type bool\r\n  HasDrill = 'hasDrill',\r\n\r\n  // DPI_HasExclude, having type bool\r\n  HasExclude = 'hasExclude',\r\n\r\n  // DPI_HasFill, having type bool\r\n  HasFill = 'hasFill',\r\n\r\n  // DPI_HasLabels, having type bool\r\n  HasLabels = 'hasLabels',\r\n\r\n  // DPI_HasLimit, having type bool\r\n  HasLimit = 'hasLimit',\r\n\r\n  // DPI_HasLine, having type bool\r\n  HasLine = 'hasLine',\r\n\r\n  // DPI_HasModifiedAxes, having type bool\r\n  HasModifiedAxes = 'hasModifiedAxes',\r\n\r\n  // DPI_HasNonRootCalculations, having type bool\r\n  HasNonRootCalculations = 'hasNonRootCalculations',\r\n\r\n  // DPI_HasOnlyOneHierarchy, having type bool\r\n  HasOnlyOneHierarchy = 'hasOnlyOneHierarchy',\r\n\r\n  // DPI_HasPattern, having type bool\r\n  HasPattern = 'hasPattern',\r\n\r\n  // DPI_HasPublishGuidanceResults, having type bool\r\n  HasPublishGuidanceResults = 'hasPublishGuidanceResults',\r\n\r\n  // DPI_HasSelection, having type bool\r\n  HasSelection = 'hasSelection',\r\n\r\n  // DPI_HasServerCredentials, having type bool\r\n  HasServerCredentials = 'hasServerCredentials',\r\n\r\n  // DPI_HasSpace, having type bool\r\n  HasSpace = 'hasSpace',\r\n\r\n  // DPI_HasStoredProcedure, having type bool\r\n  HasStoredProcedure = 'hasStoredProcedure',\r\n\r\n  // DPI_HasStringCalculatedMeasures, having type bool\r\n  HasStringCalculatedMeasures = 'hasStringCalculatedMeasures',\r\n\r\n  // DPI_HasTableCalcData, having type bool\r\n  HasTableCalcData = 'hasTableCalcData',\r\n\r\n  // DPI_HasTitle, having type bool\r\n  HasTitle = 'hasTitle',\r\n\r\n  // DPI_HasUserSpecificContent, having type bool\r\n  HasUserSpecificContent = 'hasUserSpecificContent',\r\n\r\n  // DPI_HasUnjoinedTable, having type bool\r\n  HasUnjoinedTable = 'hasUnjoinedTable',\r\n\r\n  // DPI_HasVarArgs, having type bool\r\n  HasVarArgs = 'hasVarArgs',\r\n\r\n  // DPI_HasVisitedWDCPage, having type bool\r\n  HasVisitedWDCPage = 'hasVisitedWdcPage',\r\n\r\n  // DPI_IgnoreAliases, having type bool\r\n  IgnoreAliases = 'ignoreAliases',\r\n\r\n  // DPI_IgnoreDomain, having type bool\r\n  IgnoreDomain = 'ignoreDomain',\r\n\r\n  // DPI_IgnoreSelection, having type bool\r\n  IgnoreSelection = 'ignoreSelection',\r\n\r\n  // DPI_IncludeAllColumns, having type bool\r\n  IncludeAllColumns = 'includeAllColumns',\r\n\r\n  // DPI_IncludeContext, having type bool\r\n  IncludeContext = 'includeContext',\r\n\r\n  // DPI_IncludeDashboardPresModels, having type bool\r\n  IncludeDashboardPresModels = 'includeDashboardPresModels',\r\n\r\n  // DPI_IncludeItemSet, having type bool\r\n  IncludeItemSet = 'includeItemSet',\r\n\r\n  // DPI_IncludeLocalFiles, having type bool\r\n  IncludeLocalFiles = 'includeLocalFiles',\r\n\r\n  // DPI_IncludeOtherSelected, having type bool\r\n  IncludeOtherSelected = 'includeOtherSelected',\r\n\r\n  // DPI_IncludeNulls, having type bool\r\n  IncludeNulls = 'includeNulls',\r\n\r\n  // DPI_IncludeParent, having type bool\r\n  IncludeParent = 'includeParent',\r\n\r\n  // DPI_IncludeSelections, having type bool\r\n  IncludeSelections = 'includeSelections',\r\n\r\n  // DPI_IncludeSiblings, having type bool\r\n  IncludeSiblings = 'includeSiblings',\r\n\r\n  // DPI_IncludeStories, having type bool\r\n  IncludeStories = 'includeStories',\r\n\r\n  // DPI_IncludeSubfolders, having type bool\r\n  IncludeSubfolders = 'includeSubfolders',\r\n\r\n  // DPI_IncludeVolatileProps, having type bool\r\n  IncludeVolatileProps = 'includeVolatileProps',\r\n\r\n  // DPI_IncludesTag, having type bool\r\n  IncludesTag = 'includesTag',\r\n\r\n  // DPI_InsertAfter, having type bool\r\n  InsertAfter = 'insertAfter',\r\n\r\n  // DPI_InsertAtEnd, having type bool\r\n  InsertAtEnd = 'insertAtEnd',\r\n\r\n  // DPI_InstantAnalyticsAllowed, having type bool\r\n  InstantAnalyticsAllowed = 'instantAnalyticsAllowed',\r\n\r\n  // DPI_IntegerCoordinates, having type bool\r\n  IntegerCoordinates = 'intCoords',\r\n\r\n  // DPI_InvalidatedLayout, having type bool\r\n  InvalidatedLayout = 'invalidatedLayout',\r\n\r\n  // DPI_IsActive, having type bool\r\n  IsActive = 'isActive',\r\n\r\n  // DPI_IsAddToFilter, having type bool\r\n  IsAddToFilter = 'isAddToFilterButtonChecked',\r\n\r\n  // DPI_IsAllButtonVisible, having type bool\r\n  IsAllButtonVisible = 'isAllButtonVisible',\r\n\r\n  // DPI_IsAllowedInCalcs, having type bool\r\n  IsAllowedInCalcs = 'isAllowedInCalcs',\r\n\r\n  // DPI_IsAppMapSource, having type bool\r\n  IsAppMapSource = 'isAppMapSource',\r\n\r\n  // DPI_IsArchive, having type bool\r\n  IsArchive = 'isArchive',\r\n\r\n  // DPI_IsAttributeHierarchy, having type bool\r\n  IsAttributeHierarchy = 'isAttributeHierarchy',\r\n\r\n  // DPI_IsAuthoringMode, having type bool\r\n  IsAuthoringMode = 'isAuthoringMode',\r\n\r\n  // DPI_IsAuto, having type bool\r\n  IsAuto = 'isAuto',\r\n\r\n  // DPI_IsAutoClear, having type bool\r\n  IsAutoClear = 'isAutoClear',\r\n\r\n  // DPI_IsAutoColumn, having type bool\r\n  IsAutoColumn = 'isAutoColumn',\r\n\r\n  // DPI_IsAutoHidden, having type bool\r\n  IsAutoHidden = 'isAutoHidden',\r\n\r\n  // DPI_IsAutoSelect, having type bool\r\n  IsAutoSelect = 'isAutoSelect',\r\n\r\n  // DPI_IsBold, having type bool\r\n  IsBold = 'isBold',\r\n\r\n  // DPI_IsBorderVisible, having type bool\r\n  IsBorderVisible = 'isBorderVisible',\r\n\r\n  // DPI_IsBoxplot, having type bool\r\n  IsBoxplot = 'isBoxplot',\r\n\r\n  // DPI_IsCapable, having type bool\r\n  IsCapable = 'isCapable',\r\n\r\n  // DPI_IsCaptured, having type bool\r\n  IsCaptured = 'isCaptured',\r\n\r\n  // DPI_IsCentered, having type bool\r\n  IsCentered = 'isCentered',\r\n\r\n  // DPI_IsChecked, having type bool\r\n  IsChecked = 'isChecked',\r\n\r\n  // DPI_IsColorDiverging, having type bool\r\n  IsColorDiverging = 'isColorDiverging',\r\n\r\n  // DPI_IsColorStepped, having type bool\r\n  IsColorStepped = 'isColorStepped',\r\n\r\n  // DPI_IsCombinedField, having type bool\r\n  IsCombinedField = 'isCombinedField',\r\n\r\n  // DPI_IsConnected, having type bool\r\n  IsConnected = 'isConnected',\r\n\r\n  // DPI_IsContextMenuAllowed, having type bool\r\n  IsContextMenuAllowed = 'isContextMenuAllowed',\r\n\r\n  // DPI_IsContinuous, having type bool\r\n  IsContinuous = 'isContinuous',\r\n\r\n  // DPI_IsCopy, having type bool\r\n  IsCopy = 'isCopy',\r\n\r\n  // DPI_IsCustomCalculation, having type bool\r\n  IsCustomCalculation = 'isCustomCalculation',\r\n\r\n  // DPI_IsCustomPalette, having type bool\r\n  IsCustomPalette = 'isCustomPalette',\r\n\r\n  // DPI_IsCustomSQL, having type bool\r\n  IsCustomSQL = 'isCustomSql',\r\n\r\n  // DPI_IsCustomValueEnabled, having type bool\r\n  IsCustomValueEnabled = 'isCustomValueEnabled',\r\n\r\n  // DPI_IsDataAlertConditionMet, having type bool\r\n  IsDataAlertConditionMet = 'isDataAlertConditionMet',\r\n\r\n  // DPI_IsDataAlertDialogVisible, having type bool\r\n  IsDataAlertDialogVisible = 'isDataAlertDialogVisible',\r\n\r\n  // DPI_IsDataBin, having type bool\r\n  IsDataBin = 'isDataBin',\r\n\r\n  // DPI_IsDataGridVisible, having type bool\r\n  IsDataGridVisible = 'isDataGridVisible',\r\n\r\n  // DPI_IsDatabase, having type bool\r\n  IsDatabase = 'isDatabase',\r\n\r\n  // DPI_IsDatabaseFilterInclusive, having type bool\r\n  IsDatabaseFilterInclusive = 'isDbFilterInclusive',\r\n\r\n  // DPI_IsDraggable, having type bool\r\n  IsDraggable = 'isDraggable',\r\n\r\n  // DPI_IsMDXCalculation, having type bool\r\n  IsMDXCalculation = 'isMdxCalculation',\r\n\r\n  // DPI_IsMetadata, having type bool\r\n  IsMetadata = 'isMetadata',\r\n\r\n  // DPI_IsWebDataTabViewSupported, having type bool\r\n  IsWebDataTabViewSupported = 'isWebDataTabViewSupported',\r\n\r\n  // DPI_IsPublishedDatasourceReplacement, having type bool\r\n  IsPublishedDatasourceReplacement = 'isPublishedDatasourceReplacement',\r\n\r\n  // DPI_IsDeadDrop, having type bool\r\n  IsDeadDrop = 'isDeadDrop',\r\n\r\n  // DPI_IsDefault, having type bool\r\n  IsDefault = 'isDefault',\r\n\r\n  // DPI_IsDeleteCalcConfirm, having type bool\r\n  IsDeleteCalcConfirm = 'isDeleteCalcConfirmed',\r\n\r\n  // DPI_IsDimension, having type bool\r\n  IsDimension = 'isDimension',\r\n\r\n  // DPI_IsDisabled, having type bool\r\n  IsDisabled = 'isDisabled',\r\n\r\n  // DPI_IsDivider, having type bool\r\n  IsDivider = 'isDivider',\r\n\r\n  // DPI_IsDropdownEnabled, having type bool\r\n  IsDropdownEnabled = 'isDropdownEnabled',\r\n\r\n  // DPI_IsEditing, having type bool\r\n  IsEditing = 'isEditing',\r\n\r\n  // DPI_IsEmbedded, having type bool\r\n  IsEmbedded = 'isEmbedded',\r\n\r\n  // DPI_IsEmpty, having type bool\r\n  IsEmpty = 'isEmpty',\r\n\r\n  // DPI_IsAddInEnabled, having type bool\r\n  IsAddInEnabled = 'isAddInEnabled',\r\n\r\n  // DPI_IsInDrillPath, having type bool\r\n  IsInDrillPath = 'isInDrillPath',\r\n\r\n  // DPI_AddInJSDebuggingEnabled, having type bool\r\n  AddInJSDebuggingEnabled = 'addInJsDebugginEnabled',\r\n\r\n  // DPI_AddInPauseBeforeLoading, having type bool\r\n  AddInPauseBeforeLoading = 'addInPauseBeforeLoading',\r\n\r\n  // DPI_IsDSHierarchical, having type bool\r\n  IsDSHierarchical = 'isDsHierarchical',\r\n\r\n  // DPI_IsEditorOpen, having type bool\r\n  IsEditorOpen = 'isEditorOpen',\r\n\r\n  // DPI_IsEndPtMoveable, having type bool\r\n  IsEndPtMoveable = 'isEndpointMovable',\r\n\r\n  // DPI_IsExclude, having type bool\r\n  IsExclude = 'isExcludeButtonChecked',\r\n\r\n  // DPI_IsExistingConnection, having type bool\r\n  IsExistingConnection = 'isExistingConnection',\r\n\r\n  // DPI_IsExistingObject, having type bool\r\n  IsExistingObject = 'isExistingObject',\r\n\r\n  // DPI_IsExtract, having type bool\r\n  IsExtract = 'isExtract',\r\n\r\n  // DPI_IsExtractOnlyConnection, having type bool\r\n  IsExtractOnlyConnection = 'isExtractOnlyConnection',\r\n\r\n  // DPI_IsExtractSelectionVisible, having type bool\r\n  IsExtractSelectionVisible = 'isExtractSelectionVisible',\r\n\r\n  // DPI_IsFederatable, having type bool\r\n  IsFederatable = 'isFederatable',\r\n\r\n  // DPI_IsField, having type bool\r\n  IsField = 'isField',\r\n\r\n  // DPI_IsFieldParameter, having type bool\r\n  IsFieldParameter = 'isFieldParameter',\r\n\r\n  // DPI_IsFilterActionField, having type bool\r\n  IsFilterActionField = 'isFilterActionField',\r\n\r\n  // DPI_IsFirstClassConnector, having type bool\r\n  IsFirstClassConnector = 'isFirstClassConnector',\r\n\r\n  // DPI_IsFloating, having type bool\r\n  IsFloating = 'isFloating',\r\n\r\n  // DPI_IsFolded, having type bool\r\n  IsFolded = 'isFolded',\r\n\r\n  // DPI_IsForInput, having type bool\r\n  IsForInput = 'isForInput',\r\n\r\n  // DPI_IsForecastEnabled, having type bool\r\n  IsForecastEnabled = 'isForecastEnabled',\r\n\r\n  // DPI_IsForceDirty, having type bool\r\n  IsForceDirty = 'isForceDirty',\r\n\r\n  // DPI_IsFullScan, having type bool\r\n  IsFullScan = 'isFullScan',\r\n\r\n  // DPI_IsFullStyling, having type bool\r\n  IsFullStyling = 'isFullStyling',\r\n\r\n  // DPI_IsGenerated, having type bool\r\n  IsGenerated = 'isGenerated',\r\n\r\n  // DPI_IsGlobalNames, having type bool\r\n  IsGlobalNames = 'isGlobalNames',\r\n\r\n  // DPI_IsGrayed, having type bool\r\n  IsGrayed = 'isGrayed',\r\n\r\n  // DPI_IsGrayscale, having type bool\r\n  IsGrayscale = 'isGrayscale',\r\n\r\n  // DPI_IsGroup, having type bool\r\n  IsGroup = 'isGroup',\r\n\r\n  // DPI_IsHideableField, having type bool\r\n  IsHideableField = 'isHideableField',\r\n\r\n  // DPI_IsHierarchy, having type bool\r\n  IsHierarchy = 'isHierarchy',\r\n\r\n  // DPI_IsHierarchySingleSelect, having type bool\r\n  IsHierarchySingleSelect = 'isHierarchySingleSelect',\r\n\r\n  // DPI_IsHighlightAllowed, having type bool\r\n  IsHighlightAllowed = 'isHighlightAllowed',\r\n\r\n  // DPI_IsHighlightEnabled, having type bool\r\n  IsHighlightEnabled = 'isHighlightEnabled',\r\n\r\n  // DPI_IsHighlightField, having type bool\r\n  IsHighlightField = 'isHighlightField',\r\n\r\n  // DPI_IsHorizontal, having type bool\r\n  IsHorizontal = 'isHorizontal',\r\n\r\n  // DPI_IsImageEnabled, having type bool\r\n  IsImageEnabled = 'isImageEnabled',\r\n\r\n  // DPI_IsInDefault, having type bool\r\n  IsInDefault = 'isInDefault',\r\n\r\n  // DPI_IsInPrimaryDataSource, having type bool\r\n  IsInPrimaryDataSource = 'isInPrimaryDataSource',\r\n\r\n  // DPI_IsInner, having type bool\r\n  IsInner = 'isInner',\r\n\r\n  // DPI_IsInstance, having type bool\r\n  IsInstance = 'isInstance',\r\n\r\n  // DPI_IsInvalid, having type bool\r\n  IsInvalid = 'isInvalid',\r\n\r\n  // DPI_IsInvalidCalcOnDG, having type bool\r\n  IsInvalidCalcOnDG = 'isInvalidDgCalc',\r\n\r\n  // DPI_IsItalics, having type bool\r\n  IsItalics = 'isItalics',\r\n\r\n  // DPI_IsJoinAreaVisible, having type bool\r\n  IsJoinAreaVisible = 'isJoinAreaVisible',\r\n\r\n  // DPI_IsLabels, having type bool\r\n  IsLabels = 'isLabels',\r\n\r\n  // DPI_IsLayered, having type bool\r\n  IsLayered = 'isLayered',\r\n\r\n  // DPI_IsLeft, having type bool\r\n  IsLeft = 'isLeft',\r\n\r\n  // DPI_IsLegacy, having type bool\r\n  IsLegacy = 'isLegacy',\r\n\r\n  // DPI_IsLevel, having type bool\r\n  IsLevel = 'isLevel',\r\n\r\n  // DPI_IsLevelOrLevelIdentity, having type bool\r\n  IsLevelOrLevelIdentity = 'isLevelOrLevelIdentity',\r\n\r\n  // DPI_IsLicensed, having type bool\r\n  IsLicensed = 'isLicensed',\r\n\r\n  // DPI_IsLink, having type bool\r\n  IsLink = 'isLink',\r\n\r\n  // DPI_IsLinked, having type bool\r\n  IsLinked = 'isLinked',\r\n\r\n  // DPI_IsMap, having type bool\r\n  IsMap = 'isMap',\r\n\r\n  // DPI_IsMeasure, having type bool\r\n  IsMeasure = 'isMeasure',\r\n\r\n  // DPI_IsMerge, having type bool\r\n  IsMerge = 'isMerge',\r\n\r\n  // DPI_IsMessageSourceRemote, having type bool\r\n  IsMessageSourceRemote = 'isMessageSourceRemote',\r\n\r\n  // DPI_IsMissingFromExtract, having type bool\r\n  IsMissingFromExtract = 'isMissingFromExtract',\r\n\r\n  // DPI_IsMobile, having type bool\r\n  IsMobile = 'isMobile',\r\n\r\n  // DPI_IsModified, having type bool\r\n  IsModified = 'isModified',\r\n\r\n  // DPI_IsNew, having type bool\r\n  IsNew = 'isNew',\r\n\r\n  // DPI_IsNewCloudFileDataSource, having type bool\r\n  IsNewCloudFileDataSource = 'isNewCloudFileDataSource',\r\n\r\n  // DPI_IsNewZone, having type bool\r\n  IsNewZone = 'isNewZone',\r\n\r\n  // DPI_IsNone, having type bool\r\n  IsNone = 'isNone',\r\n\r\n  // DPI_IsOfflineMode, having type bool\r\n  IsOfflineMode = 'isOfflineMode',\r\n\r\n  // DPI_IsPreAqlBin, having type bool\r\n  IsPreAqlBin = 'isPreAqlBin',\r\n\r\n  // DPI_IsOMeasuresAndRelational, having type bool\r\n  IsOMeasuresAndRelational = 'isOmeasuresAndRelational',\r\n\r\n  // DPI_IsOpaque, having type bool\r\n  IsOpaque = 'isOpaque',\r\n\r\n  // DPI_IsOrphaned, having type bool\r\n  IsOrphaned = 'isOrphaned',\r\n\r\n  // DPI_IsOverlay, having type bool\r\n  IsOverlay = 'isOverlay',\r\n\r\n  // DPI_IsOverride, having type bool\r\n  IsOverride = 'isOverride',\r\n\r\n  // DPI_IsPageLoading, having type bool\r\n  IsPageLoading = 'isPageLoading',\r\n\r\n  // DPI_IsParameterSelected, having type bool\r\n  IsParameterSelected = 'isParameterSelected',\r\n\r\n  // DPI_IsParameterSelectedOnFrom, having type bool\r\n  IsParameterSelectedOnFrom = 'isParameterSelectedOnFrom',\r\n\r\n  // DPI_IsParameterSelectedOnTo, having type bool\r\n  IsParameterSelectedOnTo = 'isParameterSelectedOnTo',\r\n\r\n  // DPI_IsPatternBased, having type bool\r\n  IsPatternBased = 'isPatternBased',\r\n\r\n  // DPI_IsPinned, having type bool\r\n  IsPinned = 'isPinned',\r\n\r\n  // DPI_IsPresentationMode, having type bool\r\n  IsPresentationMode = 'isPresentationModeDoc',\r\n\r\n  // DPI_IsPublishAllowed, having type bool\r\n  IsPublishAllowed = 'isPublishAllowed',\r\n\r\n  // DPI_IsMustDowngradeToPublish, having type bool\r\n  IsMustDowngradeToPublish = 'isDowngradeToPublishRequired',\r\n\r\n  // DPI_IsPublished, having type bool\r\n  IsPublished = 'isPublished',\r\n\r\n  // DPI_IsQuantitative, having type bool\r\n  IsQuantitative = 'isQuantitative',\r\n\r\n  // DPI_IsQuickTableCalc, having type bool\r\n  IsQuickTableCalc = 'isQuickTableCalc',\r\n\r\n  // DPI_IsRadioOn, having type bool\r\n  IsRadioOn = 'isRadioOn',\r\n\r\n  // DPI_IsReconnect, having type bool\r\n  IsReconnect = 'isReconnect',\r\n\r\n  // DPI_IsRecursive, having type bool\r\n  IsRecursive = 'isRecursive',\r\n\r\n  // DPI_IsReferenced, having type bool\r\n  IsReferenced = 'isReferenced',\r\n\r\n  // DPI_IsRemovalAllowed, having type bool\r\n  IsRemovalAllowed = 'isRowRemovalAllowed',\r\n\r\n  // DPI_IsRenderCapable, having type bool\r\n  IsRenderCapable = 'isRenderCapable',\r\n\r\n  // DPI_IsRequired, having type bool\r\n  IsRequired = 'isRequired',\r\n\r\n  // DPI_IsReversed, having type bool\r\n  IsReversed = 'isReversed',\r\n\r\n  // DPI_IsRightDrag, having type bool\r\n  IsRightDrag = 'isRightDrag',\r\n\r\n  // DPI_IsRowLabels, having type bool\r\n  IsRowLabels = 'isRowLabels',\r\n\r\n  // DPI_IsPercentage, having type bool\r\n  IsPercentage = 'isPercentage',\r\n\r\n  // DPI_IsSalesforceInConnection, having type bool\r\n  IsSalesforceInConnection = 'isSalesforceInConnection',\r\n\r\n  // DPI_IsScaled, having type bool\r\n  IsScaled = 'isScaled',\r\n\r\n  // DPI_IsSecondaryField, having type bool\r\n  IsSecondaryField = 'isSecondaryField',\r\n\r\n  // DPI_IsSelected, having type bool\r\n  IsSelected = 'isSelected',\r\n\r\n  // DPI_IsSelectedItem, having type bool\r\n  IsSelectedItem = 'isSelectedItem',\r\n\r\n  // DPI_IsSelectionDisabled, having type bool\r\n  IsSelectionDisabled = 'isSelectionDisabled',\r\n\r\n  // DPI_IsShiftDrag, having type bool\r\n  IsShiftDrag = 'isShiftDrag',\r\n\r\n  // DPI_IsSingleLabel, having type bool\r\n  IsSingleLabel = 'isSingleLabel',\r\n\r\n  // DPI_IsSingleSelect, having type bool\r\n  IsSingleSelect = 'isSingleSelect',\r\n\r\n  // DPI_IsSingleSelectMode, having type bool\r\n  IsSingleSelectMode = 'isSingleSelectMode',\r\n\r\n  // DPI_IsSingleSelection, having type bool\r\n  IsSingleSelection = 'isSingleSelection',\r\n\r\n  // DPI_IsSorted, having type bool\r\n  IsSorted = 'isSorted',\r\n\r\n  // DPI_IsSortPill, having type bool\r\n  IsSortPill = 'isSortPill',\r\n\r\n  // DPI_IsSpecial, having type bool\r\n  IsSpecial = 'isSpecial',\r\n\r\n  // DPI_IsSplashScreen, having type bool\r\n  IsSplashScreen = 'isSplashScreen',\r\n\r\n  // DPI_IsStoryEmpty, having type bool\r\n  IsStoryEmpty = 'isStoryEmpty',\r\n\r\n  // DPI_IsStrikeThrough, having type bool\r\n  IsStrikeThrough = 'isStrikeThrough',\r\n\r\n  // DPI_IsTableCalc, having type bool\r\n  IsTableCalc = 'isTableCalc',\r\n\r\n  // DPI_IsTableCleaningSubtable, having type bool\r\n  IsTableCleaningSubtable = 'isTableCleaningSubtable',\r\n\r\n  // DPI_IsTableFilterInclusive, having type bool\r\n  IsTableFilterInclusive = 'isTableFilterInclusive',\r\n\r\n  // DPI_IsTableRanked, having type bool\r\n  IsTableRanked = 'isTableRanked',\r\n\r\n  // DPI_IsTemporary, having type bool\r\n  IsTemporary = 'isTemporary',\r\n\r\n  // DPI_IsTimeIntelligence, having type bool\r\n  IsTimeIntelligence = 'isTimeIntelligence',\r\n\r\n  // DPI_IsTitleVisible, having type bool\r\n  IsTitleVisible = 'isTitleVisible',\r\n\r\n  // DPI_IsTopLevel, having type bool\r\n  IsTopLevel = 'isTopLevel',\r\n\r\n  // DPI_IsTwoValued, having type bool\r\n  IsTwoValued = 'isTwoValued',\r\n\r\n  // DPI_IsTypeInFinished, having type bool\r\n  IsTypeInFinished = 'isTypeinFinished',\r\n\r\n  // DPI_IsTypeInPill, having type bool\r\n  IsTypeInPill = 'isTypeInPill',\r\n\r\n  // DPI_IsURLActionField, having type bool\r\n  IsURLActionField = 'isUrlActionField',\r\n\r\n  // DPI_IsUnderlined, having type bool\r\n  IsUnderlined = 'isUnderlined',\r\n\r\n  // DPI_IsUnion, having type bool\r\n  IsUnion = 'isUnion',\r\n\r\n  // DPI_IsUnionReplacement, having type bool\r\n  IsUnionReplacement = 'isUnionReplacement',\r\n\r\n  // DPI_IsUnnamedCalc, having type bool\r\n  IsUnnamedCalc = 'isUnnamed',\r\n\r\n  // DPI_IsUserDefinedAttribute, having type bool\r\n  IsUserDefinedAttribute = 'isUserDefinedAttribute',\r\n\r\n  // DPI_IsUserEditable, having type bool\r\n  IsUserEditable = 'isUserEditable',\r\n\r\n  // DPI_IsUserPrompted, having type bool\r\n  IsUserPrompted = 'isUserPrompted',\r\n\r\n  // DPI_IsUserResponded, having type bool\r\n  IsUserResponded = 'isUserResponded',\r\n\r\n  // DPI_IsValid, having type bool\r\n  IsValid = 'isValid',\r\n\r\n  // DPI_IsValidWDCPage, having type bool\r\n  IsValidWDCPage = 'isValidWdcPage',\r\n\r\n  // DPI_IsVaryingAttributeDimension, having type bool\r\n  IsVaryingAttributeDimension = 'isVaryingAttributeDimension',\r\n\r\n  // DPI_IsVertical, having type bool\r\n  IsVertical = 'isVertical',\r\n\r\n  // DPI_IsViewModified, having type bool\r\n  IsViewModified = 'isViewModified',\r\n\r\n  // DPI_IsVisuallyCategorical, having type bool\r\n  IsVisuallyCategorical = 'isVisuallyCat',\r\n\r\n  // DPI_IsVizInTooltip, having type bool\r\n  IsVizInTooltip = 'isVizInTooltip',\r\n\r\n  // DPI_IsWeb, having type bool\r\n  IsWeb = 'isWeb',\r\n\r\n  // DPI_IsWhite, having type bool\r\n  IsWhite = 'isWhite',\r\n\r\n  // DPI_IsWorldNew, having type bool\r\n  IsWorldNew = 'isWorldNew',\r\n\r\n  // DPI_IsXAxis, having type bool\r\n  IsXAxis = 'isXAxis',\r\n\r\n  // DPI_KeepAspectRatio, having type bool\r\n  KeepAspectRatio = 'keepAspectRatio',\r\n\r\n  // DPI_LabelLineEndFirst, having type bool\r\n  LabelLineEndFirst = 'labelLineEndFirst',\r\n\r\n  // DPI_LabelLineEndLast, having type bool\r\n  LabelLineEndLast = 'labelLineEndLast',\r\n\r\n  // DPI_LabelMarkMax, having type bool\r\n  LabelMarkMax = 'labelMarkMax',\r\n\r\n  // DPI_LabelMarkMin, having type bool\r\n  LabelMarkMin = 'labelMarkMin',\r\n\r\n  // DPI_LockAspectRatio, having type bool\r\n  LockAspectRatio = 'lockAspectRatio',\r\n\r\n  // DPI_LoopPlayback, having type bool\r\n  LoopPlayback = 'loopPlayback',\r\n\r\n  // DPI_LossyImages, having type bool\r\n  LossyImages = 'lossyImages',\r\n\r\n  // DPI_MakeGlobal, having type bool\r\n  MakeGlobal = 'isMakeGlobal',\r\n\r\n  // DPI_ManualSortOnly, having type bool\r\n  ManualSortOnly = 'manualSortOnly',\r\n\r\n  // DPI_MapBoxDefaultStyleSelected, having type bool\r\n  MapBoxDefaultStyleSelected = 'mapboxDefaultStyleSelected',\r\n\r\n  // DPI_MapBoxURLParseSuccessful, having type bool\r\n  MapBoxURLParseSuccessful = 'mapboxUrlParseSuccessful',\r\n\r\n  // DPI_MapClientRequestsMapTiles, having type bool\r\n  MapClientRequestsMapTiles = 'clientRequestsMapTiles',\r\n\r\n  // DPI_MapHasValidLayer, having type bool\r\n  MapHasValidLayer = 'mapHasValidLayer',\r\n\r\n  // DPI_MapShowAttribution, having type bool\r\n  MapShowAttribution = 'showAttribution',\r\n\r\n  // DPI_MarkLabelsVisibilityChanged, having type bool\r\n  MarkLabelsVisibilityChanged = 'markLabelsVisibilityChanged',\r\n\r\n  // DPI_MembersLoaded, having type bool\r\n  MembersLoaded = 'membersLoaded',\r\n\r\n  // DPI_MinimizeNames, having type bool\r\n  MinimizeNames = 'useMinNames',\r\n\r\n  // DPI_ModelsTime, having type bool\r\n  ModelsTime = 'modelsTime',\r\n\r\n  // DPI_MoveRefereceLineUp, having type bool\r\n  MoveRefereceLineUp = 'moveReferenceLineUp',\r\n\r\n  // DPI_MultiDataSources, having type bool\r\n  MultiDataSources = 'multiDataSources',\r\n\r\n  // DPI_NavArrowsVisible, having type bool\r\n  NavArrowsVisible = 'navArrowsVisible',\r\n\r\n  // DPI_OEMHasSplashScreen, having type bool\r\n  OEMHasSplashScreen = 'oemHasSplashScreen',\r\n\r\n  // DPI_OneWayBrushing, having type bool\r\n  OneWayBrushing = 'oneWayBrushing',\r\n\r\n  // DPI_OnlyAggregations, having type bool\r\n  OnlyAggregations = 'onlyAggregations',\r\n\r\n  // DPI_OnlyShowDateBins, having type bool\r\n  OnlyShowDateBins = 'onlyShowDateBins',\r\n\r\n  // DPI_OverrideAllowed, having type bool\r\n  OverrideAllowed = 'overrideAllowed',\r\n\r\n  // DPI_OverrideStackDumper, having type bool\r\n  OverrideStackDumper = 'overrideStackDumper',\r\n\r\n  // DPI_PageAutoColorLines, having type bool\r\n  PageAutoColorLines = 'autoColorLines',\r\n\r\n  // DPI_PageAutoColorMarks, having type bool\r\n  PageAutoColorMarks = 'autoColorMarks',\r\n\r\n  // DPI_PageHistoryFade, having type bool\r\n  PageHistoryFade = 'historyFade',\r\n\r\n  // DPI_PercentageBands, having type bool\r\n  PercentageBands = 'percentageBands',\r\n\r\n  // DPI_PercentilesAllowed, having type bool\r\n  PercentilesAllowed = 'percentilesAllowed',\r\n\r\n  // DPI_PublishWithRemoteQueryAgent, having type bool\r\n  PublishWithRemoteQueryAgent = 'publishWithRemoteQueryAgent',\r\n\r\n  // DPI_PreviousSheet, having type bool\r\n  PreviousSheet = 'previousSheet',\r\n\r\n  // DPI_PromptDeleteSheetsWithVizInTooltip, having type bool\r\n  PromptDeleteSheetsWithVizInTooltip = 'promptDeleteSheetsWithVizInTooltip',\r\n\r\n  // DPI_QuantilesAllowed, having type bool\r\n  QuantilesAllowed = 'quantilesAllowed',\r\n\r\n  // DPI_RadialDistanceHitTest, having type bool\r\n  RadialDistanceHitTest = 'radialDistanceHitTest',\r\n\r\n  // DPI_RefLineSelected, having type bool\r\n  RefLineSelected = 'refLineSelected',\r\n\r\n  // DPI_RemovedSheets, having type bool\r\n  RemovedSheets = 'removedSheets',\r\n\r\n  // DPI_RenderImagesAsUrls, having type bool\r\n  RenderImagesAsUrls = 'imagesAsUrls',\r\n\r\n  // DPI_RenderOnTop, having type bool\r\n  RenderOnTop = 'renderOnTop',\r\n\r\n  // DPI_RepeatHeadersLegends, having type bool\r\n  RepeatHeadersLegends = 'repeatHeadersLegends',\r\n\r\n  // DPI_ReplaceActiveConfig, having type bool\r\n  ReplaceActiveConfig = 'replaceActiveConfig',\r\n\r\n  // DPI_ReplaceDatasourceAfterPublish, having type bool\r\n  ReplaceDatasourceAfterPublish = 'replaceDatasourceAfterPublish',\r\n\r\n  // DPI_ReplaceDatasourceFailed, having type bool\r\n  ReplaceDatasourceFailed = 'replaceDatasourceFailed',\r\n\r\n  // DPI_ReplaceTde, having type bool\r\n  ReplaceTde = 'replaceTde',\r\n\r\n  // DPI_RequireSelection, having type bool\r\n  RequireSelection = 'requireSelection',\r\n\r\n  // DPI_RequiresDBVariables, having type bool\r\n  RequiresDBVariables = 'requiresDbVariables',\r\n\r\n  // DPI_RequiresFieldList, having type bool\r\n  RequiresFieldList = 'requiresFieldList',\r\n\r\n  // DPI_RestartEveryFieldIsInvalid, having type bool\r\n  RestartEveryFieldIsInvalid = 'restartEveryFieldIsInvalid',\r\n\r\n  // DPI_RightJustify, having type bool\r\n  RightJustify = 'rightJustify',\r\n\r\n  // DPI_SaveEnabled, having type bool\r\n  SaveEnabled = 'saveEnabled',\r\n\r\n  // DPI_SavePasswordAllowed, having type bool\r\n  SavePasswordAllowed = 'savePasswordAllowed',\r\n\r\n  // DPI_ScopeIsolation, having type bool\r\n  ScopeIsolation = 'scopeIsolation',\r\n\r\n  // DPI_SelectionRequired, having type bool\r\n  SelectionRequired = 'selectionRequired',\r\n\r\n  // DPI_SendNotifications, having type bool\r\n  SendNotifications = 'sendNotifications',\r\n\r\n  // DPI_SetActive, having type bool\r\n  SetActive = 'setActive',\r\n\r\n  // DPI_SetDefaultSort, having type bool\r\n  SetDefaultSort = 'setDefault',\r\n\r\n  // DPI_SheetIsDashboard, having type bool\r\n  SheetIsDashboard = 'isDashboard',\r\n\r\n  // DPI_SheetIsStoryboard, having type bool\r\n  SheetIsStoryboard = 'isStory',\r\n\r\n  // DPI_ShouldAlwaysDisplayAlias, having type bool\r\n  ShouldAlwaysDisplayAlias = 'shouldAlwaysDisplayAlias',\r\n\r\n  // DPI_ShouldAutoCapture, having type bool\r\n  ShouldAutoCapture = 'shouldAutoCapture',\r\n\r\n  // DPI_ShouldAutoRevert, having type bool\r\n  ShouldAutoRevert = 'shouldAutoRevert',\r\n\r\n  // DPI_ShouldChangeUIMode, having type bool\r\n  ShouldChangeUIMode = 'shouldChangeUiMode',\r\n\r\n  // DPI_ShouldDisplay, having type bool\r\n  ShouldDisplay = 'shouldDisplay',\r\n\r\n  // DPI_ShouldDrill, having type bool\r\n  ShouldDrill = 'shouldDrill',\r\n\r\n  // DPI_ShouldForceConnectionAttempt, having type bool\r\n  ShouldForceConnectionAttempt = 'shouldForceConnectionAttempt',\r\n\r\n  // DPI_ShouldRefreshDS, having type bool\r\n  ShouldRefreshDS = 'shouldRefreshDs',\r\n\r\n  // DPI_ShouldScaleMarksInAxisUnits, having type bool\r\n  ShouldScaleMarksInAxisUnits = 'shouldScaleMarksInAxisUnits',\r\n\r\n  // DPI_ShouldSeedCredentials, having type bool\r\n  ShouldSeedCredentials = 'shouldSeedCredentials',\r\n\r\n  // DPI_ShouldShowDataSourceConnectionError, having type bool\r\n  ShouldShowDataSourceConnectionError = 'shouldShowDataSourceConnectionError',\r\n\r\n  // DPI_ShouldShowDistance, having type bool\r\n  ShouldShowDistance = 'shouldShowDistance',\r\n\r\n  // DPI_ShouldShowHiddenField, having type bool\r\n  ShouldShowHiddenField = 'shouldShowHiddenField',\r\n\r\n  // DPI_ShouldShowMapScale, having type bool\r\n  ShouldShowMapScale = 'shouldShowMapScale',\r\n\r\n  // DPI_ShouldURLEscape, having type bool\r\n  ShouldURLEscape = 'shouldUrlEscape',\r\n\r\n  // DPI_ShouldUpdateDomainInfo, having type bool\r\n  ShouldUpdateDomainInfo = 'shouldUpdateDomInfo',\r\n\r\n  // DPI_ShowAddToFilter, having type bool\r\n  ShowAddToFilter = 'showAddToFilterButton',\r\n\r\n  // DPI_ShowAliases, having type bool\r\n  ShowAliases = 'showAliases',\r\n\r\n  // DPI_ShowAllPages, having type bool\r\n  ShowAllPages = 'showAllPages',\r\n\r\n  // DPI_ShowApply, having type bool\r\n  ShowApply = 'showApplyButton',\r\n\r\n  // DPI_ShowApplyAndCancelButtons, having type bool\r\n  ShowApplyAndCancelButtons = 'showApplyAndCancelButtons',\r\n\r\n  // DPI_ShowAuthenticationOptions, having type bool\r\n  ShowAuthenticationOptions = 'showAuthenticationOptions',\r\n\r\n  // DPI_ShowAuthenticationSetting, having type bool\r\n  ShowAuthenticationSetting = 'showAuthenticationSetting',\r\n\r\n  // DPI_ShowAuto, having type bool\r\n  ShowAuto = 'showAuto',\r\n\r\n  // DPI_ShowBold, having type bool\r\n  ShowBold = 'showBoldOption',\r\n\r\n  // DPI_ShowButtons, having type bool\r\n  ShowButtons = 'showButtons',\r\n\r\n  // DPI_ShowCaption, having type bool\r\n  ShowCaption = 'showCaption',\r\n\r\n  // DPI_ShowColorLegend, having type bool\r\n  ShowColorLegend = 'showColorLegend',\r\n\r\n  // DPI_ShowDataGridInlineRename, having type bool\r\n  ShowDataGridInlineRename = 'showDataGridInlineRename',\r\n\r\n  // DPI_ShowDetailMessages, having type bool\r\n  ShowDetailMessages = 'showDetailMessages',\r\n\r\n  // DPI_ShowDate, having type bool\r\n  ShowDate = 'showDate',\r\n\r\n  // DPI_ShowDragLabel, having type bool\r\n  ShowDragLabel = 'showDragLabel',\r\n\r\n  // DPI_ShowDropMeasures, having type bool\r\n  ShowDropMeasures = 'showDropMeasures',\r\n\r\n  // DPI_ShowEmbedAll, having type bool\r\n  ShowEmbedAll = 'showEmbedAll',\r\n\r\n  // DPI_ShowEntireImage, having type bool\r\n  ShowEntireImage = 'showEntireImage',\r\n\r\n  // DPI_ShowExclude, having type bool\r\n  ShowExclude = 'showExcludeButton',\r\n\r\n  // DPI_ShowFloatingZoomToolbar, having type bool\r\n  ShowFloatingZoomToolbar = 'showFloatingZoomToolbar',\r\n\r\n  // DPI_ShowFormatter, having type bool\r\n  ShowFormatter = 'showFormatter',\r\n\r\n  // DPI_ShowFullSchedules, having type bool\r\n  ShowFullSchedules = 'showFullSchedules',\r\n\r\n  // DPI_ShowGeographicSearch, having type bool\r\n  ShowGeographicSearch = 'showGeographicSearch',\r\n\r\n  // DPI_ShowHiddenFields, having type bool\r\n  ShowHiddenFields = 'showHiddenFields',\r\n\r\n  // DPI_ShowHistoryControls, having type bool\r\n  ShowHistoryControls = 'showHistoryControls',\r\n\r\n  // DPI_ShowIncludeLocalFiles, having type bool\r\n  ShowIncludeLocalFiles = 'showIncludeLocalFiles',\r\n\r\n  // DPI_ShowIncludeOtherOption, having type bool\r\n  ShowIncludeOtherOption = 'showIncludeOtherOption',\r\n\r\n  // DPI_ShowIncludeSelections, having type bool\r\n  ShowIncludeSelections = 'showIncludeSelections',\r\n\r\n  // DPI_ShowIncrSchedules, having type bool\r\n  ShowIncrSchedules = 'showIncrSchedules',\r\n\r\n  // DPI_ShowInnerMostLevel, having type bool\r\n  ShowInnerMostLevel = 'showInnermostLevel',\r\n\r\n  // DPI_ShowItalics, having type bool\r\n  ShowItalics = 'showItalicsOption',\r\n\r\n  // DPI_ShowLegend, having type bool\r\n  ShowLegend = 'showLegend',\r\n\r\n  // DPI_ShowLockedPermissionsIcon, having type bool\r\n  ShowLockedPermissionsIcon = 'showLockedPermissionsIcon',\r\n\r\n  // DPI_ShowManageDatasources, having type bool\r\n  ShowManageDatasources = 'showManageDatasources',\r\n\r\n  // DPI_ShowMapLegend, having type bool\r\n  ShowMapLegend = 'showMapLegend',\r\n\r\n  // DPI_ShowMapScale, having type bool\r\n  ShowMapScale = 'showMapScale',\r\n\r\n  // DPI_ShowMappedFilterCols, having type bool\r\n  ShowMappedFilterCols = 'showMappedFilterColumns',\r\n\r\n  // DPI_ShowName, having type bool\r\n  ShowName = 'showName',\r\n\r\n  // DPI_ShowNone, having type bool\r\n  ShowNone = 'showNone',\r\n\r\n  // DPI_ShowPagePlayback, having type bool\r\n  ShowPagePlayback = 'showPagePlayback',\r\n\r\n  // DPI_ShowPageReadout, having type bool\r\n  ShowPageReadout = 'showPageReadout',\r\n\r\n  // DPI_ShowPageSlider, having type bool\r\n  ShowPageSlider = 'showPageSlider',\r\n\r\n  // DPI_ShowParent, having type bool\r\n  ShowParent = 'showParent',\r\n\r\n  // DPI_ShowPercentages, having type bool\r\n  ShowPercentages = 'showPercentages',\r\n\r\n  // DPI_ShowPredictionIntervals, having type bool\r\n  ShowPredictionIntervals = 'showPredictionIntervals',\r\n\r\n  // DPI_ShowPublishedDatasources, having type bool\r\n  ShowPublishedDatasources = 'showPublishedDatasources',\r\n\r\n  // DPI_ShowRelDatePicker, having type bool\r\n  ShowRelDatePicker = 'showRelDatePicker',\r\n\r\n  // DPI_ShowReplaceDatasource, having type bool\r\n  ShowReplaceDatasource = 'showReplaceDatasource',\r\n\r\n  // DPI_ShowSeparator, having type bool\r\n  ShowSeparator = 'showSeparator',\r\n\r\n  // DPI_ShowShapeLegend, having type bool\r\n  ShowShapeLegend = 'showShapeLegend',\r\n\r\n  // DPI_ShowSizeLegend, having type bool\r\n  ShowSizeLegend = 'showSizeLegend',\r\n\r\n  // DPI_ShowShelf, having type bool\r\n  ShowShelf = 'showShelf',\r\n\r\n  // DPI_ShowStructure, having type bool\r\n  ShowStructure = 'showStructure',\r\n\r\n  // DPI_ShowSyncClientOptions, having type bool\r\n  ShowSyncClientOptions = 'showSyncClientOptions',\r\n\r\n  // DPI_ShowTabsAllowed, having type bool\r\n  ShowTabsAllowed = 'showTabsAllowed',\r\n\r\n  // DPI_ShowTime, having type bool\r\n  ShowTime = 'showTime',\r\n\r\n  // DPI_ShowTitle, having type bool\r\n  ShowTitle = 'showTitle',\r\n\r\n  // DPI_ShowTransSlider, having type bool\r\n  ShowTransSlider = 'showTransparencySlider',\r\n\r\n  // DPI_ShowUnderline, having type bool\r\n  ShowUnderline = 'showUnderlineOption',\r\n\r\n  // DPI_ShowUserThumbnailOptions, having type bool\r\n  ShowUserThumbnailOptions = 'showUserThumbnailOptions',\r\n\r\n  // DPI_ShowView, having type bool\r\n  ShowView = 'showView',\r\n\r\n  // DPI_ShowViews, having type bool\r\n  ShowViews = 'showViews',\r\n\r\n  // DPI_ShowingPageLoadError, having type bool\r\n  ShowingPageLoadError = 'showingPageLoadError',\r\n\r\n  // DPI_SupressAliases, having type bool\r\n  SupressAliases = 'suspressAliases',\r\n\r\n  // DPI_SupressThousandsSeparator, having type bool\r\n  SupressThousandsSeparator = 'supressThousandsSeparator',\r\n\r\n  // DPI_SingleSelectOnly, having type bool\r\n  SingleSelectOnly = 'singleSelectOnly',\r\n\r\n  // DPI_SkipIfActive, having type bool\r\n  SkipIfActive = 'skipIfActive',\r\n\r\n  // DPI_SkipRefresh, having type bool\r\n  SkipRefresh = 'skipRefresh',\r\n\r\n  // DPI_SkipValidation, having type bool\r\n  SkipValidation = 'skipValidation',\r\n\r\n  // DPI_Skipped, having type bool\r\n  Skipped = 'skipped',\r\n\r\n  // DPI_SortFieldIsInvalid, having type bool\r\n  SortFieldIsInvalid = 'sortFieldIsInvalid',\r\n\r\n  // DPI_SortModeIsAuto, having type bool\r\n  SortModeIsAuto = 'sortModeIsAuto',\r\n\r\n  // DPI_SplitOnEdgeSnap, having type bool\r\n  SplitOnEdgeSnap = 'splitOnEdgeSnap',\r\n\r\n  // DPI_StandardDeviationAllowed, having type bool\r\n  StandardDeviationAllowed = 'standardDeviationAllowed',\r\n\r\n  // DPI_State, having type bool\r\n  State = 'state',\r\n\r\n  // DPI_StoredProcDisabled, having type bool\r\n  StoredProcDisabled = 'storedProcDisabled',\r\n\r\n  // DPI_StoredProcsDropable, having type bool\r\n  StoredProcsDropable = 'storedProcsDropable',\r\n\r\n  // DPI_StoryIsEmpty, having type bool\r\n  StoryIsEmpty = 'storyIsEmpty',\r\n\r\n  // DPI_StoryPointIsEmpty, having type bool\r\n  StoryPointIsEmpty = 'storyPointIsEmpty',\r\n\r\n  // DPI_SuccessfulSave, having type bool\r\n  SuccessfulSave = 'successfulSave',\r\n\r\n  // DPI_SupportXAxis, having type bool\r\n  SupportXAxis = 'supportXAxis',\r\n\r\n  // DPI_SupportYAxis, having type bool\r\n  SupportYAxis = 'supportYAxis',\r\n\r\n  // DPI_SupportsCenterAlignment, having type bool\r\n  SupportsCenterAlignment = 'supportsCenterAlignment',\r\n\r\n  // DPI_SupportsDBFilters, having type bool\r\n  SupportsDBFilters = 'supportsDatabaseFilters',\r\n\r\n  // DPI_SupportsMultipleValues, having type bool\r\n  SupportsMultipleValues = 'supportsMultipleValues',\r\n\r\n  // DPI_SupportsRightAlignment, having type bool\r\n  SupportsRightAlignment = 'supportsRightAlignment',\r\n\r\n  // DPI_SupportsTableFilters, having type bool\r\n  SupportsTableFilters = 'supportsTableFilters',\r\n\r\n  // DPI_Symmetric, having type bool\r\n  Symmetric = 'symmetric',\r\n\r\n  // DPI_SyncAutomaticDrill, having type bool\r\n  SyncAutomaticDrill = 'syncAutomaticDrill',\r\n\r\n  // DPI_TabsAllowed, having type bool\r\n  TabsAllowed = 'tabsAllowed',\r\n\r\n  // DPI_TextDropdownState, having type bool\r\n  TextDropdownState = 'toggleState',\r\n\r\n  // DPI_TitleInline, having type bool\r\n  TitleInline = 'titleInline',\r\n\r\n  // DPI_ToggleHighlightStateChanged, having type bool\r\n  ToggleHighlightStateChanged = 'toggleHighlight',\r\n\r\n  // DPI_Transformed80Format, having type bool\r\n  Transformed80Format = 'oldFormat',\r\n\r\n  // DPI_TrendLineSelected, having type bool\r\n  TrendLineSelected = 'trendLineSelected',\r\n\r\n  // DPI_TruncDate, having type bool\r\n  TruncDate = 'truncDate',\r\n\r\n  // DPI_TupleSelected, having type bool\r\n  TupleSelected = 'tupleSelected',\r\n\r\n  // DPI_UIAutomationDidPageLoad, having type bool\r\n  UIAutomationDidPageLoad = 'uiAutomationDidPageLoad',\r\n\r\n  // DPI_UIAutomationIsChecked, having type bool\r\n  UIAutomationIsChecked = 'uiAutomationIsChecked',\r\n\r\n  // DPI_UIAutomationIsEnabled, having type bool\r\n  UIAutomationIsEnabled = 'uiAutomationIsEnabled',\r\n\r\n  // DPI_UIAutomationIsEventProcessed, having type bool\r\n  UIAutomationIsEventProcessed = 'uiAutomationIsEventProcessed',\r\n\r\n  // DPI_UIAutomationIsFocused, having type bool\r\n  UIAutomationIsFocused = 'uiAutomationIsFocused',\r\n\r\n  // DPI_UIAutomationIsFound, having type bool\r\n  UIAutomationIsFound = 'uiAutomationIsFound',\r\n\r\n  // DPI_UIAutomationIsReadonly, having type bool\r\n  UIAutomationIsReadonly = 'uiAutomationIsReadonly',\r\n\r\n  // DPI_UIAutomationIsSelected, having type bool\r\n  UIAutomationIsSelected = 'uiAutomationIsSelected',\r\n\r\n  // DPI_UpdateAllPanes, having type bool\r\n  UpdateAllPanes = 'updateAllPanes',\r\n\r\n  // DPI_UpdateDSCaptionOnly, having type bool\r\n  UpdateDSCaptionOnly = 'updateDsCaptionOnly',\r\n\r\n  // DPI_UpdateModelFromParams, having type bool\r\n  UpdateModelFromParams = 'updateModelFromParams',\r\n\r\n  // DPI_UpdateShelves, having type bool\r\n  UpdateShelves = 'updateShelves',\r\n\r\n  // DPI_UpdatesUseContext, having type bool\r\n  UpdatesUseContext = 'updatesUseContext',\r\n\r\n  // DPI_UpgradeDocumentVersion, having type bool\r\n  UpgradeDocumentVersion = 'upgradeDocumentVersion',\r\n\r\n  // DPI_UseAliases, having type bool\r\n  UseAliases = 'useAliases',\r\n\r\n  // DPI_UseBlankForNull, having type bool\r\n  UseBlankForNull = 'useBlankForNull',\r\n\r\n  // DPI_UseCalculationEditor, having type bool\r\n  UseCalculationEditor = 'useCalculationEditor',\r\n\r\n  // DPI_UseCenterValue, having type bool\r\n  UseCenterValue = 'useCenterValue',\r\n\r\n  // DPI_UseColor, having type bool\r\n  UseColor = 'useColor',\r\n\r\n  // DPI_UseCustomMarkSize, having type bool\r\n  UseCustomMarkSize = 'useCustomMarkSize',\r\n\r\n  // DPI_UseDarkIcons, having type bool\r\n  UseDarkIcons = 'useDarkIcons',\r\n\r\n  // DPI_UseDataStoreMinfiedNames, having type bool\r\n  UseDataStoreMinfiedNames = 'useDatastoreMinNames',\r\n\r\n  // DPI_UseInitialDomainType, having type bool\r\n  UseInitialDomainType = 'useInitialDomainType',\r\n\r\n  // DPI_UseEndValue, having type bool\r\n  UseEndValue = 'useEndValue',\r\n\r\n  // DPI_UseForOverlayHitTest, having type bool\r\n  UseForOverlayHitTest = 'useForOverlayHitTest',\r\n\r\n  // DPI_UseFullColorRange, having type bool\r\n  UseFullColorRange = 'useFullColorRange',\r\n\r\n  // DPI_UseFullDomain, having type bool\r\n  UseFullDomain = 'useFullDomain',\r\n\r\n  // DPI_UseInlineImages, having type bool\r\n  UseInlineImages = 'useInlineImages',\r\n\r\n  // DPI_UseMeasures, having type bool\r\n  UseMeasures = 'useMeasures',\r\n\r\n  // DPI_UseNewQuickFilters, having type bool\r\n  UseNewQuickFilters = 'useNewQuickFilters',\r\n\r\n  // DPI_UseNotificationReturn, having type bool\r\n  UseNotificationReturn = 'useNotificationReturn',\r\n\r\n  // DPI_UseParameters, having type bool\r\n  UseParameters = 'useParameters',\r\n\r\n  // DPI_UseSelector, having type bool\r\n  UseSelector = 'useSelector',\r\n\r\n  // DPI_UseSignificantDigits, having type bool\r\n  UseSignificantDigits = 'useSignificantDigits',\r\n\r\n  // DPI_UseSpecialStrings, having type bool\r\n  UseSpecialStrings = 'useSpecialStrings',\r\n\r\n  // DPI_UseStartValue, having type bool\r\n  UseStartValue = 'useStartValue',\r\n\r\n  // DPI_UseTabs, having type bool\r\n  UseTabs = 'useTabs',\r\n\r\n  // DPI_UseTabletAsDefaultPreview, having type bool\r\n  UseTabletAsDefaultPreview = 'useTabletAsDefaultPreview',\r\n\r\n  // DPI_UseTargetPt, having type bool\r\n  UseTargetPt = 'useTargetPoint',\r\n\r\n  // DPI_UseUSLocale, having type bool\r\n  UseUSLocale = 'useUsLocale',\r\n\r\n  // DPI_UseYAxis, having type bool\r\n  UseYAxis = 'useYAxis',\r\n\r\n  // DPI_Valid, having type bool\r\n  Valid = 'valid',\r\n\r\n  // DPI_VizDataV82, having type bool\r\n  VizDataV82 = 'vizData82',\r\n\r\n  // DPI_WMSConnectionSuccessful, having type bool\r\n  WMSConnectionSuccessful = 'wmsConnectionSuccessful',\r\n\r\n  // DPI_WMSShouldUseTiles, having type bool\r\n  WMSShouldUseTiles = 'wmsShouldUseTiles',\r\n\r\n  // DPI_WantDomain, having type bool\r\n  WantDomain = 'wantDomain',\r\n\r\n  // DPI_WorkbookModified, having type bool\r\n  WorkbookModified = 'workbookModified',\r\n\r\n  // DPI_ZoomIn, having type bool\r\n  ZoomIn = 'zoomIn',\r\n\r\n  // DPI_ShowMarkLabels, having type bool\r\n  ShowMarkLabels = 'showMarkLabels',\r\n\r\n  // DPI_HasDuplicates, having type bool\r\n  HasDuplicates = 'hasDuplicates',\r\n\r\n  // DPI_HasUserDefinedIncrement, having type bool\r\n  HasUserDefinedIncrement = 'hasUserDefinedIncrement',\r\n\r\n  // DPI_HasUserDefinedMax, having type bool\r\n  HasUserDefinedMax = 'hasUserDefinedMax',\r\n\r\n  // DPI_HasUserDefinedMin, having type bool\r\n  HasUserDefinedMin = 'hasUserDefinedMin',\r\n\r\n  // DPI_IsDuplicate, having type bool\r\n  IsDuplicate = 'isDuplicate',\r\n\r\n  // DPI_IsEditingValue, having type bool\r\n  IsEditingValue = 'isEditingValue',\r\n\r\n  // DPI_ShouldRestrictDataType, having type bool\r\n  ShouldRestrictDataType = 'restrictDataType',\r\n\r\n  // DPI_EnableIncludeZero, having type bool\r\n  EnableIncludeZero = 'enableIncludeZero',\r\n\r\n  // DPI_EnableSyncDualAxes, having type bool\r\n  EnableSyncDualAxes = 'enableSynchronizeDualAxes',\r\n\r\n  // DPI_EnableShowTimes, having type bool\r\n  EnableShowTimes = 'enableShowTimes',\r\n\r\n  // DPI_EnableTickMarksTab, having type bool\r\n  EnableTickMarksTab = 'enableTickMarksTab',\r\n\r\n  // DPI_IsTemporal, having type bool\r\n  IsTemporal = 'isTemporal',\r\n\r\n  // DPI_ShouldIncludeZero, having type bool\r\n  ShouldIncludeZero = 'shouldIncludeZero',\r\n\r\n  // DPI_ShouldReverseAxis, having type bool\r\n  ShouldReverseAxis = 'shouldReverseAxis',\r\n\r\n  // DPI_ShouldShowTimes, having type bool\r\n  ShouldShowTimes = 'shouldShowTimes',\r\n\r\n  // DPI_UseAutomaticAxisSubtitle, having type bool\r\n  UseAutomaticAxisSubtitle = 'useAutomaticSubtitle',\r\n\r\n  // DPI_UseAutomaticAxisTitle, having type bool\r\n  UseAutomaticAxisTitle = 'useAutomaticTitle',\r\n\r\n  // DPI_AllSelected, having type bool\r\n  AllSelected = 'allSelected',\r\n\r\n  // DPI_AutoCommit, having type bool\r\n  AutoCommit = 'autoCommit',\r\n\r\n  // DPI_CacheOnly, having type bool\r\n  CacheOnly = 'cacheOnly',\r\n\r\n  // DPI_IncludeData, having type bool\r\n  IncludeData = 'includeData',\r\n\r\n  // DPI_IsPatternExclusive, having type bool\r\n  IsPatternExclusive = 'isPatternExclusive',\r\n\r\n  // DPI_IsSearchable, having type bool\r\n  IsSearchable = 'isSearchable',\r\n\r\n  // DPI_IsSelectionExclusive, having type bool\r\n  IsSelectionExclusive = 'isSelectionExclusive',\r\n\r\n  // DPI_ResetNewFilter, having type bool\r\n  ResetNewFilter = 'resetNewFilter',\r\n\r\n  // DPI_UseAllWhenManualEmpty, having type bool\r\n  UseAllWhenManualEmpty = 'useAllWhenManualEmpty',\r\n\r\n  // DPI_UseAllWhenPatternEmpty, having type bool\r\n  UseAllWhenPatternEmpty = 'useAllWhenPatternEmpty',\r\n\r\n  // DPI_GroupByDrillDown, having type bool\r\n  GroupByDrillDown = 'groupByDrillDown',\r\n\r\n  // DPI_GroupByTable, having type bool\r\n  GroupByTable = 'groupByTable',\r\n\r\n  // DPI_IncludeGroups, having type bool\r\n  IncludeGroups = 'includeGroups',\r\n\r\n  // DPI_IncludePendingState, having type bool\r\n  IncludePendingState = 'includePendingState',\r\n\r\n  // DPI_IncludeFieldMenus, having type bool\r\n  IncludeFieldMenus = 'includeFieldMenus',\r\n\r\n  // DPI_IncludeFormattedValues, having type bool\r\n  IncludeFormattedValues = 'includeFormattedValues',\r\n\r\n  // DPI_IncludeColumnInstances, having type bool\r\n  IncludeColumnInstances = 'includeColumnInstances',\r\n\r\n  // DPI_IncludeAdHocCalcs, having type bool\r\n  IncludeAdHocCalcs = 'includeAdhocCalcs',\r\n\r\n  // DPI_IncludeHiddenInvalidFields, having type bool\r\n  IncludeHiddenInvalidFields = 'includeHiddenInvalidFields',\r\n\r\n  // DPI_IncludeNonExtractedColumns, having type bool\r\n  IncludeNonExtractedColumns = 'includeNonExtractedColumns',\r\n\r\n  // DPI_IncludeCalculatedFieldFormulas, having type bool\r\n  IncludeCalculatedFieldFormulas = 'includeCalculatedFieldFormulas',\r\n\r\n  // DPI_SetDataPreviewCustomFieldOrder, having type bool\r\n  SetDataPreviewCustomFieldOrder = 'setDataPreviewCustomFieldOrder',\r\n\r\n  // DPI_CustomSplitAllowSplitFromRight, having type bool\r\n  CustomSplitAllowSplitFromRight = 'customSplitAllowSplitFromRight',\r\n\r\n  // DPI_IsChanged, having type bool\r\n  IsChanged = 'isChanged',\r\n\r\n  // DPI_ShowFontColorPicker, having type bool\r\n  ShowFontColorPicker = 'showFontColorPicker',\r\n\r\n  // DPI_ShowFontFamilyPicker, having type bool\r\n  ShowFontFamilyPicker = 'showFontFamilyPicker',\r\n\r\n  // DPI_ShowFontSizePicker, having type bool\r\n  ShowFontSizePicker = 'showFontSizePicker',\r\n\r\n  // DPI_ShowFontStyleButtons, having type bool\r\n  ShowFontStyleButtons = 'showFontStyleButtons',\r\n\r\n  // DPI_ShowLineForAll, having type bool\r\n  ShowLineForAll = 'showLineForAll',\r\n\r\n  // DPI_ShowLineForColumn, having type bool\r\n  ShowLineForColumn = 'showLineForColumn',\r\n\r\n  // DPI_ShowLineForRow, having type bool\r\n  ShowLineForRow = 'showLineForRow',\r\n\r\n  // DPI_ShowLinePatternPicker, having type bool\r\n  ShowLinePatternPicker = 'showLinePatternPicker',\r\n\r\n  // DPI_ShowLineTransparency, having type bool\r\n  ShowLineTransparency = 'showLineTransparency',\r\n\r\n  // DPI_ShowLineWidthPicker, having type bool\r\n  ShowLineWidthPicker = 'showLineWidthPicker',\r\n\r\n  // DPI_CanBeAuto, having type bool\r\n  CanBeAuto = 'canBeAuto',\r\n\r\n  // DPI_CanBeNone, having type bool\r\n  CanBeNone = 'canBeNone',\r\n\r\n  // DPI_CanMatchMarkColor, having type bool\r\n  CanMatchMarkColor = 'canMatchMarkColor',\r\n\r\n  // DPI_HasOpacity, having type bool\r\n  HasOpacity = 'hasOpacity',\r\n\r\n  // DPI_IncludeAllHidden, having type bool\r\n  IncludeAllHidden = 'includeAllHidden',\r\n\r\n  // DPI_IncludeCurrent, having type bool\r\n  IncludeCurrent = 'includeCurrent',\r\n\r\n  // DPI_IsIncluded, having type bool\r\n  IsIncluded = 'isIncluded',\r\n\r\n  // DPI_IsRelative, having type bool\r\n  IsRelative = 'isRelative',\r\n\r\n  // DPI_IsSecondaryAllowed, having type bool\r\n  IsSecondaryAllowed = 'isSecondaryAllowed',\r\n\r\n  // DPI_NullIfIncomplete, having type bool\r\n  NullIfIncomplete = 'nullIfIncomplete',\r\n\r\n  // DPI_IsCalcAssistanceEnabled, having type bool\r\n  IsCalcAssistanceEnabled = 'isCalcAssistanceEnabled',\r\n\r\n  // DPI_UseSecondaryCalc, having type bool\r\n  UseSecondaryCalc = 'useSecondaryCalc',\r\n\r\n  // DPI_CanLoad, having type bool\r\n  CanLoad = 'canLoad',\r\n\r\n  // DPI_DescriptionOnly, having type bool\r\n  DescriptionOnly = 'descriptionOnly',\r\n\r\n  // DPI_AreAliasesSupported, having type bool\r\n  AreAliasesSupported = 'areAliasesSupported',\r\n\r\n  // DPI_AreRefColumnsSupported, having type bool\r\n  AreRefColumnsSupported = 'areRefColumnsSupported',\r\n\r\n  // DPI_IsAggregated, having type bool\r\n  IsAggregated = 'isAggregated',\r\n\r\n  // DPI_IsExportSupported, having type bool\r\n  IsExportSupported = 'isExportSupported',\r\n\r\n  // DPI_IsMeasureNames, having type bool\r\n  IsMeasureNames = 'isMeasureNames',\r\n\r\n  // DPI_IsSummarySupported, having type bool\r\n  IsSummarySupported = 'isSummarySupported',\r\n\r\n  // DPI_IsTopNSupported, having type bool\r\n  IsTopNSupported = 'isTopNSupported',\r\n\r\n  // DPI_IsUnderlyingSupported, having type bool\r\n  IsUnderlyingSupported = 'isUnderlyingSupported',\r\n\r\n  // DPI_OnlyExportSummary, having type bool\r\n  OnlyExportSummary = 'onlyExportSummary',\r\n\r\n  // DPI_ShowAllFields, having type bool\r\n  ShowAllFields = 'showAllFields',\r\n\r\n  // DPI_UseTablePtrs, having type bool\r\n  UseTablePtrs = 'useTablePtrs',\r\n\r\n  // DPI_OnlyFetchSummary, having type bool\r\n  OnlyFetchSummary = 'onlyFetchSummary',\r\n\r\n  // DPI_IsDeviceLayoutCustomized, having type bool\r\n  IsDeviceLayoutCustomized = 'isDeviceLayoutCustomized',\r\n\r\n  // DPI_IsDeviceSizeCustomized, having type bool\r\n  IsDeviceSizeCustomized = 'isDeviceSizeCustomized',\r\n\r\n  // DPI_IsDeviceSupportedByMobileApp, having type bool\r\n  IsDeviceSupportedByMobileApp = 'isDeviceSupportedByMobileApp',\r\n\r\n  // DPI_IsPortrait, having type bool\r\n  IsPortrait = 'isPortrait',\r\n\r\n  // DPI_IsPortraitByDefault, having type bool\r\n  IsPortraitByDefault = 'isPortraitByDefault',\r\n\r\n  // DPI_IsUserCustomFormat, having type bool\r\n  IsUserCustomFormat = 'isUserCustomFormat',\r\n\r\n  // DPI_ShouldDisplayRebuildExtractMessage, having type bool\r\n  ShouldDisplayRebuildExtractMessage = 'shouldDisplayRebuildExtractMessage',\r\n\r\n  // DPI_SupportsCustomStartOfWeek, having type bool\r\n  SupportsCustomStartOfWeek = 'supportsCustomStartOfWeek',\r\n\r\n  // DPI_NeedsConnectPrompt, having type bool\r\n  NeedsConnectPrompt = 'needsConnectPrompt',\r\n\r\n  // DPI_NeedsCloseDataSourceErrorPrompt, having type bool\r\n  NeedsCloseDataSourceErrorPrompt = 'needsCloseDsErrorPrompt',\r\n\r\n  // DPI_ClearCurrentSelection, having type bool\r\n  ClearCurrentSelection = 'clearCurrentSelection',\r\n\r\n  // DPI_HasContains, having type bool\r\n  HasContains = 'hasContains',\r\n\r\n  // DPI_HasEndsWith, having type bool\r\n  HasEndsWith = 'hasEndsWith',\r\n\r\n  // DPI_HasReplaceSelection, having type bool\r\n  HasReplaceSelection = 'hasReplaceSelection',\r\n\r\n  // DPI_HasStartsWith, having type bool\r\n  HasStartsWith = 'hasStartsWith',\r\n\r\n  // DPI_IsLeafSelectionOnly, having type bool\r\n  IsLeafSelectionOnly = 'isLeafSelectionOnly',\r\n\r\n  // DPI_ReplaceSelection, having type bool\r\n  ReplaceSelection = 'replaceSelection',\r\n\r\n  // DPI_IsColorPaletteCustomized, having type bool\r\n  IsColorPaletteCustomized = 'isColorPaletteCustomized',\r\n\r\n  // DPI_ReversePaletteOrder, having type bool\r\n  ReversePaletteOrder = 'reversePaletteOrder',\r\n\r\n  // DPI_TriedToConnect, having type bool\r\n  TriedToConnect = 'triedToConnect',\r\n\r\n  // DPI_ScaleMarksInAxisUnits, having type bool\r\n  ScaleMarksInAxisUnits = 'scaleMarksInAxisUnits',\r\n\r\n  // DPI_ShowMarkSizingOptions, having type bool\r\n  ShowMarkSizingOptions = 'showMarkSizingOptions',\r\n\r\n  // DPI_UseSizeFieldCaption, having type bool\r\n  UseSizeFieldCaption = 'useSizeFieldCaption',\r\n\r\n  // DPI_IsLicensedAndRegistered, having type bool\r\n  IsLicensedAndRegistered = 'isLicensedAndRegistered',\r\n\r\n  // DPI_SetNewDatasourceActive, having type bool\r\n  SetNewDatasourceActive = 'setNewDatasourceActive',\r\n\r\n  // DPI_AllowCustomLabel, having type bool\r\n  AllowCustomLabel = 'allowCustomLabel',\r\n\r\n  // DPI_IsMostRecentModeValid, having type bool\r\n  IsMostRecentModeValid = 'isMostRecentModeValid',\r\n\r\n  // DPI_MustShowLabels, having type bool\r\n  MustShowLabels = 'mustShowLabels',\r\n\r\n  // DPI_ShowRunningOrderLabels, having type bool\r\n  ShowRunningOrderLabels = 'showRunningOrderLabels',\r\n\r\n  // DPI_IsDroppedFile, having type bool\r\n  IsDroppedFile = 'isDroppedFile',\r\n\r\n  // DPI_IsInitialized, having type bool\r\n  IsInitialized = 'isInitialized',\r\n\r\n  // DPI_IncludeDashboard, having type bool\r\n  IncludeDashboard = 'includeDashboard',\r\n\r\n  // DPI_ChildrenCanResize, having type bool\r\n  ChildrenCanResize = 'childrenCanResize',\r\n\r\n  // DPI_BoolMap, having type Dictionary(of bool)\r\n  BoolMap = 'boolMap',\r\n\r\n  // DPI_CheckedMenuItems, having type bool[]\r\n  CheckedMenuItems = 'checkedMenuItems',\r\n\r\n  // DPI_IncludedSheetValues, having type bool[]\r\n  IncludedSheetValues = 'includedSheetValues',\r\n\r\n  // DPI_SortOrderVector, having type bool[]\r\n  SortOrderVector = 'sortOrderVector',\r\n\r\n  // DPI_ActionName, having type string\r\n  ActionName = 'actionName',\r\n\r\n  // DPI_ActionSourceText, having type string\r\n  ActionSourceText = 'actionSourceText',\r\n\r\n  // DPI_ActionTypeAsString, having type string\r\n  ActionTypeAsString = 'actionTypeAsString',\r\n\r\n  // DPI_ActiveTab, having type string\r\n  ActiveTab = 'active_tab',\r\n\r\n  // DPI_AddInFeatureName, having type string\r\n  AddInFeatureName = 'addInFeatureName',\r\n\r\n  // DPI_AddInId, having type string\r\n  AddInId = 'addInId',\r\n\r\n  // DPI_AddInstanceId, having type string\r\n  AddInstanceId = 'addInInstanceId',\r\n\r\n  // DPI_AddInName, having type string\r\n  AddInName = 'addInName',\r\n\r\n  // DPI_AddInLocale, having type string\r\n  AddInLocale = 'addInLocale',\r\n\r\n  // DPI_AddInLanguage, having type string\r\n  AddInLanguage = 'addInLanguage',\r\n\r\n  // DPI_APIVersion, having type string\r\n  APIVersion = 'apiVersion',\r\n\r\n  // DPI_Alias, having type string\r\n  Alias = 'alias',\r\n\r\n  // DPI_AnchorDate, having type string\r\n  AnchorDate = 'anchorDate',\r\n\r\n  // DPI_AnnotationRes, having type string\r\n  AnnotationRes = 'annotationRes',\r\n\r\n  // DPI_ReadId, having type string\r\n  ReadId = 'readId',\r\n\r\n  // DPI_AnnotationText, having type string\r\n  AnnotationText = 'annotationText',\r\n\r\n  // DPI_ArchiveDirectory, having type string\r\n  ArchiveDirectory = 'archiveDirectory',\r\n\r\n  // DPI_ArchiveFullPath, having type string\r\n  ArchiveFullPath = 'archiveFullPath',\r\n\r\n  // DPI_AtTheLevelInvalidFieldCaption, having type string\r\n  AtTheLevelInvalidFieldCaption = 'atTheLevelInvalidFieldCaption',\r\n\r\n  // DPI_AutoCompleteSubstring, having type string\r\n  AutoCompleteSubstring = 'acSubstring',\r\n\r\n  // DPI_AutosaveFileId, having type string\r\n  AutosaveFileId = 'autosaveFileId',\r\n\r\n  // DPI_AutosaveTimerInterval, having type string\r\n  AutosaveTimerInterval = 'autosaveTimerInterval',\r\n\r\n  // DPI_BaseColumnCaption, having type string\r\n  BaseColumnCaption = 'baseColumnCaption',\r\n\r\n  // DPI_ButtonObjectClickAction, having type string\r\n  ButtonObjectClickAction = 'buttonObjectClickAction',\r\n\r\n  // DPI_ButtonObjectImagePath, having type string\r\n  ButtonObjectImagePath = 'buttonObjectImagePath',\r\n\r\n  // DPI_ClearButtonText, having type string\r\n  ClearButtonText = 'clearButtonText',\r\n\r\n  // DPI_ColorPaletteId, having type string\r\n  ColorPaletteId = 'colorPaletteId',\r\n\r\n  // DPI_ColorPaletteName, having type string\r\n  ColorPaletteName = 'colorPaletteName',\r\n\r\n  // DPI_ColorSwatch, having type string\r\n  ColorSwatch = 'colorSwatch',\r\n\r\n  // DPI_CommandName, having type string\r\n  CommandName = 'commandName',\r\n\r\n  // DPI_ConfidenceLevelValue, having type string\r\n  ConfidenceLevelValue = 'confidenceLevelValue',\r\n\r\n  // DPI_CountDistinctStr, having type string\r\n  CountDistinctStr = 'countDistinctStr',\r\n\r\n  // DPI_CrossTabFilepath, having type string\r\n  CrossTabFilepath = 'crossTabFilepath',\r\n\r\n  // DPI_CSSMargin, having type string\r\n  CSSMargin = 'cssMargin',\r\n\r\n  // DPI_CSSWhitespace, having type string\r\n  CSSWhitespace = 'cssWhitespace',\r\n\r\n  // DPI_DBPassword, having type string\r\n  DBPassword = 'dbPassword',\r\n\r\n  // DPI_DBUsername, having type string\r\n  DBUsername = 'dbUsername',\r\n\r\n  // DPI_DataAlertConditionText, having type string\r\n  DataAlertConditionText = 'dataAlertConditionText',\r\n\r\n  // DPI_DataAlertMeasureText, having type string\r\n  DataAlertMeasureText = 'dataAlertMeasureText',\r\n\r\n  // DPI_DataAlertSpecSerializedText, having type string\r\n  DataAlertSpecSerializedText = 'dataAlertSpecSerializedText',\r\n\r\n  // DPI_DataAlertDefaultSubject, having type string\r\n  DataAlertDefaultSubject = 'dataAlertDefaultSubject',\r\n\r\n  // DPI_DataAlertThresholdText, having type string\r\n  DataAlertThresholdText = 'dataAlertThresholdText',\r\n\r\n  // DPI_DataGridSortColumnName, having type string\r\n  DataGridSortColumnName = 'datagridSortColumnName',\r\n\r\n  // DPI_DataServerConnectionError, having type string\r\n  DataServerConnectionError = 'dataServerConnectionError',\r\n\r\n  // DPI_DatabaseFilter, having type string\r\n  DatabaseFilter = 'databaseFilter',\r\n\r\n  // DPI_DatabaseFilterPrompt, having type string\r\n  DatabaseFilterPrompt = 'databaseFilterPrompt',\r\n\r\n  // DPI_DatasourceRanking, having type string\r\n  DatasourceRanking = 'datasourceRanking',\r\n\r\n  // DPI_DatasourceUrl, having type string\r\n  DatasourceUrl = 'datasourceUrl',\r\n\r\n  // DPI_DatasourceUsername, having type string\r\n  DatasourceUsername = 'datasourceUsername',\r\n\r\n  // DPI_DateFormat, having type string\r\n  DateFormat = 'dateFormat',\r\n\r\n  // DPI_DatePart, having type string\r\n  DatePart = 'datePart',\r\n\r\n  // DPI_DatePartAbbrev, having type string\r\n  DatePartAbbrev = 'datePartAbbrev',\r\n\r\n  // DPI_DefaultHierarchyName, having type string\r\n  DefaultHierarchyName = 'defaultHierarchyName',\r\n\r\n  // DPI_DefaultMenuItemKey, having type string\r\n  DefaultMenuItemKey = 'defaultMenuItemKey',\r\n\r\n  // DPI_Delimiter, having type string\r\n  Delimiter = 'delimiter',\r\n\r\n  // DPI_DeviceName, having type string\r\n  DeviceName = 'deviceName',\r\n\r\n  // DPI_DeviceType, having type string\r\n  DeviceType = 'deviceType',\r\n\r\n  // DPI_DisplayPath, having type string\r\n  DisplayPath = 'displayPath',\r\n\r\n  // DPI_DistributionValueString, having type string\r\n  DistributionValueString = 'distributionValueString',\r\n\r\n  // DPI_DrillPathName, having type string\r\n  DrillPathName = 'drillPathName',\r\n\r\n  // DPI_EmbeddedTitle, having type string\r\n  EmbeddedTitle = 'embeddedTitle',\r\n\r\n  // DPI_EnterValueText, having type string\r\n  EnterValueText = 'enterValueText',\r\n\r\n  // DPI_EscapeString, having type string\r\n  EscapeString = 'escapeString',\r\n\r\n  // DPI_ExtSvcConfigHost, having type string\r\n  ExtSvcConfigHost = 'extSvcConfigHost',\r\n\r\n  // DPI_ExtSvcConfigPassword, having type string\r\n  ExtSvcConfigPassword = 'extSvcConfigPassword',\r\n\r\n  // DPI_ExtSvcConfigPort, having type string\r\n  ExtSvcConfigPort = 'extSvcConfigPort',\r\n\r\n  // DPI_ExtSvcConfigConnectTimeout, having type string\r\n  ExtSvcConfigConnectTimeout = 'extSvcConnectTimeout',\r\n\r\n  // DPI_ExtSvcConfigPrevHost, having type string\r\n  ExtSvcConfigPrevHost = 'extSvcConfigPrevHost',\r\n\r\n  // DPI_ExtSvcConfigUsername, having type string\r\n  ExtSvcConfigUsername = 'extSvcConfigUsername',\r\n\r\n  // DPI_ExtractUpdateTime, having type string\r\n  ExtractUpdateTime = 'extractUpdateTime',\r\n\r\n  // DPI_FieldFolderName, having type string\r\n  FieldFolderName = 'fieldFolderName',\r\n\r\n  // DPI_FieldNameString, having type string\r\n  FieldNameString = 'fieldName',\r\n\r\n  // DPI_FilterSearchDomain, having type string\r\n  FilterSearchDomain = 'filterSearchDomain',\r\n\r\n  // DPI_FilterSpec, having type string\r\n  FilterSpec = 'filterSpec',\r\n\r\n  // DPI_FirstValue, having type string\r\n  FirstValue = 'firstValue',\r\n\r\n  // DPI_FolderName, having type string\r\n  FolderName = 'folderName',\r\n\r\n  // DPI_FontName, having type string\r\n  FontName = 'fontName',\r\n\r\n  // DPI_FormatString, having type string\r\n  FormatString = 'formatString',\r\n\r\n  // DPI_FormattedDisplayString, having type string\r\n  FormattedDisplayString = 'formattedDisplayString',\r\n\r\n  // DPI_FormattedIncrementValue, having type string\r\n  FormattedIncrementValue = 'formattedIncrement',\r\n\r\n  // DPI_FormattedMaxValue, having type string\r\n  FormattedMaxValue = 'formattedMax',\r\n\r\n  // DPI_FormattedMinValue, having type string\r\n  FormattedMinValue = 'formattedMin',\r\n\r\n  // DPI_FormattedValue, having type string\r\n  FormattedValue = 'formattedValue',\r\n\r\n  // DPI_FormattedCenterValue, having type string\r\n  FormattedCenterValue = 'formattedCenter',\r\n\r\n  // DPI_FormattedEndValue, having type string\r\n  FormattedEndValue = 'formattedEnd',\r\n\r\n  // DPI_FormattedStartValue, having type string\r\n  FormattedStartValue = 'formattedStart',\r\n\r\n  // DPI_PairedFormattedValue, having type string\r\n  PairedFormattedValue = 'pairedFormattedValue',\r\n\r\n  // DPI_FrameAttributes, having type string\r\n  FrameAttributes = 'frameAttr',\r\n\r\n  // DPI_GUID, having type string\r\n  GUID = 'guid',\r\n\r\n  // DPI_GeographicSearchCandidateDisplayName, having type string\r\n  GeographicSearchCandidateDisplayName = 'geographicSearchCandidateDisplayName',\r\n\r\n  // DPI_GeographicSearchCandidateParentName, having type string\r\n  GeographicSearchCandidateParentName = 'geographicSearchCandidateParentName',\r\n\r\n  // DPI_GeographicSearchCandidateType, having type string\r\n  GeographicSearchCandidateType = 'geographicSearchCandidateType',\r\n\r\n  // DPI_GeographicSearchLocale, having type string\r\n  GeographicSearchLocale = 'geographicSearchLocale',\r\n\r\n  // DPI_GeographicSearchQueryString, having type string\r\n  GeographicSearchQueryString = 'geographicSearchSearchString',\r\n\r\n  // DPI_GeographicSearchUILocale, having type string\r\n  GeographicSearchUILocale = 'geographicSearchUilocale',\r\n\r\n  // DPI_IconRes, having type string\r\n  IconRes = 'iconRes',\r\n\r\n  // DPI_ImageHash, having type string\r\n  ImageHash = 'imageHash',\r\n\r\n  // DPI_ImageName, having type string\r\n  ImageName = 'imageName',\r\n\r\n  // DPI_ImageRes, having type string\r\n  ImageRes = 'imageRes',\r\n\r\n  // DPI_IncludesSiblingsPrompt, having type string\r\n  IncludesSiblingsPrompt = 'includesSiblingsPrompt',\r\n\r\n  // DPI_IncludesSubfoldersPrompt, having type string\r\n  IncludesSubfoldersPrompt = 'includesSubfoldersPrompt',\r\n\r\n  // DPI_IncrementalScheduleIDs, having type string\r\n  IncrementalScheduleIDs = 'incrementalScheduleIds',\r\n\r\n  // DPI_InvariantKeyword, having type string\r\n  InvariantKeyword = 'invariantKeyword',\r\n\r\n  // DPI_JoinOperator, having type string\r\n  JoinOperator = 'joinOperator',\r\n\r\n  // DPI_JoinExpression, having type string\r\n  JoinExpression = 'joinExpression',\r\n\r\n  // DPI_Key, having type string\r\n  Key = 'keyId',\r\n\r\n  // DPI_Label, having type string\r\n  Label = 'label',\r\n\r\n  // DPI_PairedLabel, having type string\r\n  PairedLabel = 'pairedLabel',\r\n\r\n  // DPI_LayoutID, having type string\r\n  LayoutID = 'layoutId',\r\n\r\n  // DPI_LeftJoinExpression, having type string\r\n  LeftJoinExpression = 'leftJoinExpression',\r\n\r\n  // DPI_LimitCountExpression, having type string\r\n  LimitCountExpression = 'limitCountExpression',\r\n\r\n  // DPI_LinkTarget, having type string\r\n  LinkTarget = 'linkTarget',\r\n\r\n  // DPI_Locale, having type string\r\n  Locale = 'locale',\r\n\r\n  // DPI_LocalizedKeyword, having type string\r\n  LocalizedKeyword = 'localizedKeyword',\r\n\r\n  // DPI_MapBoxGLStyleId, having type string\r\n  MapBoxGLStyleId = 'mapboxGlStyleId',\r\n\r\n  // DPI_MapBoxStyleUrl, having type string\r\n  MapBoxStyleUrl = 'mapboxStyleUrl',\r\n\r\n  // DPI_MapBoxUsername, having type string\r\n  MapBoxUsername = 'mapboxUsername',\r\n\r\n  // DPI_MapScaleReadoutString, having type string\r\n  MapScaleReadoutString = 'mapScaleReadoutString',\r\n\r\n  // DPI_MapScaleTooltipString, having type string\r\n  MapScaleTooltipString = 'mapScaleTooltipString',\r\n\r\n  // DPI_MapSourceName, having type string\r\n  MapSourceName = 'mapSourceName',\r\n\r\n  // DPI_MaxLabel, having type string\r\n  MaxLabel = 'maxLabel',\r\n\r\n  // DPI_MinLabel, having type string\r\n  MinLabel = 'minLabel',\r\n\r\n  // DPI_ModelDescriptionParagraph, having type string\r\n  ModelDescriptionParagraph = 'modelDescriptionParagraph',\r\n\r\n  // DPI_NameTemplate, having type string\r\n  NameTemplate = 'nameTemplate',\r\n\r\n  // DPI_NewDrillPath, having type string\r\n  NewDrillPath = 'newDrillPath',\r\n\r\n  // DPI_NewFieldFolderName, having type string\r\n  NewFieldFolderName = 'newFieldFolderName',\r\n\r\n  // DPI_NewTableAlias, having type string\r\n  NewTableAlias = 'newTableAlias',\r\n\r\n  // DPI_NonFormattedValue, having type string\r\n  NonFormattedValue = 'unformattedValue',\r\n\r\n  // DPI_OAuthUserName, having type string\r\n  OAuthUserName = 'oauthUsername',\r\n\r\n  // DPI_ObjectName, having type string\r\n  ObjectName = 'objectName',\r\n\r\n  // DPI_ObjectOverrideMessage, having type string\r\n  ObjectOverrideMessage = 'objectOverrideMessage',\r\n\r\n  // DPI_OldTableAlias, having type string\r\n  OldTableAlias = 'oldTableAlias',\r\n\r\n  // DPI_OperatingSystem, having type string\r\n  OperatingSystem = 'operatingSystem',\r\n\r\n  // DPI_OriginalFilePath, having type string\r\n  OriginalFilePath = 'originalFilePath',\r\n\r\n  // DPI_OriginalFileVersion, having type string\r\n  OriginalFileVersion = 'originalFileVersion',\r\n\r\n  // DPI_PaneDescriptorKey, having type string\r\n  PaneDescriptorKey = 'paneDescrKey',\r\n\r\n  // DPI_ParentName, having type string\r\n  ParentName = 'parentName',\r\n\r\n  // DPI_ParentTable, having type string\r\n  ParentTable = 'parentTable',\r\n\r\n  // DPI_PatternFilterString, having type string\r\n  PatternFilterString = 'patternFilterString',\r\n\r\n  // DPI_PendingCalcName, having type string\r\n  PendingCalcName = 'pendingCalcName',\r\n\r\n  // DPI_PercentilesString, having type string\r\n  PercentilesString = 'percentilesString',\r\n\r\n  // DPI_ProjectName, having type string\r\n  ProjectName = 'projectName',\r\n\r\n  // DPI_PropertyName, having type string\r\n  PropertyName = 'propertyName',\r\n\r\n  // DPI_QuickFilterTitleCaption, having type string\r\n  QuickFilterTitleCaption = 'quickFilterTitleCaption',\r\n\r\n  // DPI_RangeDiffStr, having type string\r\n  RangeDiffStr = 'diffValue',\r\n\r\n  // DPI_RangeMaxStr, having type string\r\n  RangeMaxStr = 'maxValue',\r\n\r\n  // DPI_RangeMinStr, having type string\r\n  RangeMinStr = 'minValue',\r\n\r\n  // DPI_RecoveredFilePath, having type string\r\n  RecoveredFilePath = 'recoveredFilePath',\r\n\r\n  // DPI_ReferenceLineSpecificationId, having type string\r\n  ReferenceLineSpecificationId = 'referenceLineId',\r\n\r\n  // DPI_ReplaceFieldPrompt, having type string\r\n  ReplaceFieldPrompt = 'replaceFieldPrompt',\r\n\r\n  // DPI_RightJoinExpression, having type string\r\n  RightJoinExpression = 'rightJoinExpression',\r\n\r\n  // DPI_RootPath, having type string\r\n  RootPath = 'rootPath',\r\n\r\n  // DPI_RuntimeFinalDatastore, having type string\r\n  RuntimeFinalDatastore = 'runtimeFinalDatastore',\r\n\r\n  // DPI_RuntimeInitialDatastore, having type string\r\n  RuntimeInitialDatastore = 'runtimeInitialDatastore',\r\n\r\n  // DPI_RuntimeVTL, having type string\r\n  RuntimeVTL = 'runtimeVtl',\r\n\r\n  // DPI_SampleDataString, having type string\r\n  SampleDataString = 'sampleData',\r\n\r\n  // DPI_ScheduleIDs, having type string\r\n  ScheduleIDs = 'scheduleIds',\r\n\r\n  // DPI_SchemaFieldIconResource, having type string\r\n  SchemaFieldIconResource = 'fieldIconRes',\r\n\r\n  // DPI_ScreenName, having type string\r\n  ScreenName = 'screenName',\r\n\r\n  // DPI_ScriptCommand, having type string\r\n  ScriptCommand = 'command',\r\n\r\n  // DPI_SecondValue, having type string\r\n  SecondValue = 'secondValue',\r\n\r\n  // DPI_SelectedValue, having type string\r\n  SelectedValue = 'selectedValue',\r\n\r\n  // DPI_ShapeName, having type string\r\n  ShapeName = 'shapeName',\r\n\r\n  // DPI_SheetId, having type string\r\n  SheetId = 'sheetId',\r\n\r\n  // DPI_ShowDataTable, having type string\r\n  ShowDataTable = 'showDataTable',\r\n\r\n  // DPI_SimpleCommand, having type string\r\n  SimpleCommand = 'simpleCommand',\r\n\r\n  // DPI_SortModeCaption, having type string\r\n  SortModeCaption = 'sortModeCaption',\r\n\r\n  // DPI_SourceName, having type string\r\n  SourceName = 'sourceName',\r\n\r\n  // DPI_SourceText, having type string\r\n  SourceText = 'sourceText',\r\n\r\n  // DPI_SpecialValueText, having type string\r\n  SpecialValueText = 'specialValueText',\r\n\r\n  // DPI_StaticImage, having type string\r\n  StaticImage = 'staticImage',\r\n\r\n  // DPI_StoryPointBase, having type string\r\n  StoryPointBase = 'storyPointBase',\r\n\r\n  // DPI_StoryPointCaption, having type string\r\n  StoryPointCaption = 'storyPointCaption',\r\n\r\n  // DPI_Storyboard, having type string\r\n  Storyboard = 'storyboard',\r\n\r\n  // DPI_StyledLabel, having type string\r\n  StyledLabel = 'styledLabel',\r\n\r\n  // DPI_SummaryCaption, having type string\r\n  SummaryCaption = 'summaryCaption',\r\n\r\n  // DPI_SummaryField, having type string\r\n  SummaryField = 'summaryField',\r\n\r\n  // DPI_TableauVersion, having type string\r\n  TableauVersion = 'tableauVersion',\r\n\r\n  // DPI_TableFilter, having type string\r\n  TableFilter = 'tableFilter',\r\n\r\n  // DPI_TableFilterPrompt, having type string\r\n  TableFilterPrompt = 'tableFilterPrompt',\r\n\r\n  // DPI_TagsLabel, having type string\r\n  TagsLabel = 'tagsLabel',\r\n\r\n  // DPI_Target, having type string\r\n  Target = 'target',\r\n\r\n  // DPI_ThumbnailGroup, having type string\r\n  ThumbnailGroup = 'thumbnailGroup',\r\n\r\n  // DPI_ThumbnailUser, having type string\r\n  ThumbnailUser = 'thumbnailUser',\r\n\r\n  // DPI_TimeFormat, having type string\r\n  TimeFormat = 'timeFormat',\r\n\r\n  // DPI_TrendLineErrorString, having type string\r\n  TrendLineErrorString = 'trendLineErrorString',\r\n\r\n  // DPI_TrendLineModelFormula, having type string\r\n  TrendLineModelFormula = 'trendLineModelFormula',\r\n\r\n  // DPI_URLString, having type string\r\n  URLString = 'urlString',\r\n\r\n  // DPI_URLTest, having type string\r\n  URLTest = 'urlTest',\r\n\r\n  // DPI_ValidationMessage, having type string\r\n  ValidationMessage = 'validationMessage',\r\n\r\n  // DPI_ValueStr, having type string\r\n  ValueStr = 'valueString',\r\n\r\n  // DPI_VerifiedNonFormattedValue, having type string\r\n  VerifiedNonFormattedValue = 'verifiedUnformattedValue',\r\n\r\n  // DPI_WorkbookFullPath, having type string\r\n  WorkbookFullPath = 'workbookFullPath',\r\n\r\n  // DPI_WindowTitle, having type string\r\n  WindowTitle = 'windowTitle',\r\n\r\n  // DPI_ZoneName, having type string\r\n  ZoneName = 'zoneName',\r\n\r\n  // DPI_ZoneParam, having type string\r\n  ZoneParam = 'zoneParam',\r\n\r\n  // DPI_DataAlertErrorText, having type string\r\n  DataAlertErrorText = 'dataAlertErrorText',\r\n\r\n  // DPI_ExtractTempDirectory, having type string\r\n  ExtractTempDirectory = 'extractTempDir',\r\n\r\n  // DPI_DSSubClass, having type string\r\n  DSSubClass = 'dsSubClass',\r\n\r\n  // DPI_DbgCommandLine, having type string\r\n  DbgCommandLine = 'debugCommandLine',\r\n\r\n  // DPI_DbgLogPath, having type string\r\n  DbgLogPath = 'debugLogPath',\r\n\r\n  // DPI_DbgOSVersion, having type string\r\n  DbgOSVersion = 'debugOsVersion',\r\n\r\n  // DPI_DbgUserName, having type string\r\n  DbgUserName = 'debugUsername',\r\n\r\n  // DPI_ErrorMsg, having type string\r\n  ErrorMsg = 'errorMessage',\r\n\r\n  // DPI_ErrorStackTrace, having type string\r\n  ErrorStackTrace = 'errorStackTrace',\r\n\r\n  // DPI_ErrorStr, having type string\r\n  ErrorStr = 'errorString',\r\n\r\n  // DPI_EventMessage, having type string\r\n  EventMessage = 'eventMessage',\r\n\r\n  // DPI_EventTimestamp, having type string\r\n  EventTimestamp = 'eventTimestamp',\r\n\r\n  // DPI_ExtractDeltaPath, having type string\r\n  ExtractDeltaPath = 'extractDeltaPath',\r\n\r\n  // DPI_ExtractPath, having type string\r\n  ExtractPath = 'extractPath',\r\n\r\n  // DPI_ExtractSuggestedPath, having type string\r\n  ExtractSuggestedPath = 'suggestedExtractPath',\r\n\r\n  // DPI_ExtractTaskSummary, having type string\r\n  ExtractTaskSummary = 'extractTaskSummary',\r\n\r\n  // DPI_FactorsString, having type string\r\n  FactorsString = 'factorsStr',\r\n\r\n  // DPI_FormattedFamilyName, having type string\r\n  FormattedFamilyName = 'formattedFamilyName',\r\n\r\n  // DPI_FunctionSignature, having type string\r\n  FunctionSignature = 'funcSig',\r\n\r\n  // DPI_FunctionTooltip, having type string\r\n  FunctionTooltip = 'funcTooltip',\r\n\r\n  // DPI_HelpContents, having type string\r\n  HelpContents = 'helpContents',\r\n\r\n  // DPI_MapAttributionText, having type string\r\n  MapAttributionText = 'mapAttributionText',\r\n\r\n  // DPI_MapAttributionTextSize, having type string\r\n  MapAttributionTextSize = 'mapAttributionTextSize',\r\n\r\n  // DPI_MapAttributionUrl, having type string\r\n  MapAttributionUrl = 'mapAttributionUrl',\r\n\r\n  // DPI_MapBoxErrorMessage, having type string\r\n  MapBoxErrorMessage = 'mapboxErrorMessage',\r\n\r\n  // DPI_MapBoxOldStyleName, having type string\r\n  MapBoxOldStyleName = 'mapboxOldStyleName',\r\n\r\n  // DPI_MapBoxSelectedStyle, having type string\r\n  MapBoxSelectedStyle = 'mapboxSelectedStyle',\r\n\r\n  // DPI_MapBoxStyleName, having type string\r\n  MapBoxStyleName = 'mapboxStyleName',\r\n\r\n  // DPI_MapLayerRequest, having type string\r\n  MapLayerRequest = 'mapLayerRequest',\r\n\r\n  // DPI_MapServerKey, having type string\r\n  MapServerKey = 'mapServerKey',\r\n\r\n  // DPI_MapTileServer, having type string\r\n  MapTileServer = 'mapTileServer',\r\n\r\n  // DPI_MapTileUrl, having type string\r\n  MapTileUrl = 'mapTileUrl',\r\n\r\n  // DPI_PercentagesString, having type string\r\n  PercentagesString = 'percentagesStr',\r\n\r\n  // DPI_PublishErrorMessage, having type string\r\n  PublishErrorMessage = 'publishErrorMessage',\r\n\r\n  // DPI_TdePath, having type string\r\n  TdePath = 'tdePath',\r\n\r\n  // DPI_UIAutomationComponentName, having type string\r\n  UIAutomationComponentName = 'uiAutomationComponentName',\r\n\r\n  // DPI_UIAutomationEndTime, having type string\r\n  UIAutomationEndTime = 'uiAutomationEndTime',\r\n\r\n  // DPI_UIAutomationName, having type string\r\n  UIAutomationName = 'uiAutomationName',\r\n\r\n  // DPI_UIAutomationStartTime, having type string\r\n  UIAutomationStartTime = 'uiAutomationStartTime',\r\n\r\n  // DPI_UIAutomationValue, having type string\r\n  UIAutomationValue = 'uiAutomationValue',\r\n\r\n  // DPI_WMSConnectionName, having type string\r\n  WMSConnectionName = 'wmsConnectionName',\r\n\r\n  // DPI_WMSOldConnectionName, having type string\r\n  WMSOldConnectionName = 'wmsOldConnectionName',\r\n\r\n  // DPI_WMSServerUrl, having type string\r\n  WMSServerUrl = 'wmsServerUrl',\r\n\r\n  // DPI_AboutBuildVersion, having type string\r\n  AboutBuildVersion = 'aboutBuildVersion',\r\n\r\n  // DPI_ActionFields, having type string\r\n  ActionFields = 'actionFields',\r\n\r\n  // DPI_AddVariableLabel, having type string\r\n  AddVariableLabel = 'addVariableLabel',\r\n\r\n  // DPI_AddVariableTooltip, having type string\r\n  AddVariableTooltip = 'addVariableTooltip',\r\n\r\n  // DPI_AllowedDataSourcesByName, having type string\r\n  AllowedDataSourcesByName = 'allowedDataSourcesByName',\r\n\r\n  // DPI_AppAboutVersion, having type string\r\n  AppAboutVersion = 'appAboutVersion',\r\n\r\n  // DPI_AppBuildBranchName, having type string\r\n  AppBuildBranchName = 'appBuildBranchName',\r\n\r\n  // DPI_AppBuildVersion, having type string\r\n  AppBuildVersion = 'appBuildVersion',\r\n\r\n  // DPI_AppExternalVersion, having type string\r\n  AppExternalVersion = 'appExternalVersion',\r\n\r\n  // DPI_AppName, having type string\r\n  AppName = 'appName',\r\n\r\n  // DPI_AppProductVersion, having type string\r\n  AppProductVersion = 'appProductVersion',\r\n\r\n  // DPI_OriginalVersion, having type string\r\n  OriginalVersion = 'originalVersion',\r\n\r\n  // DPI_AtTheLevelSpecialCaption, having type string\r\n  AtTheLevelSpecialCaption = 'atTheLevelSpecialCaption',\r\n\r\n  // DPI_AutoCompleteCalc, having type string\r\n  AutoCompleteCalc = 'acCalc',\r\n\r\n  // DPI_CSVPath, having type string\r\n  CSVPath = 'csvPath',\r\n\r\n  // DPI_CommandNamespace, having type string\r\n  CommandNamespace = 'commandNamespace',\r\n\r\n  // DPI_Condition, having type string\r\n  Condition = 'condition',\r\n\r\n  // DPI_ConditionSummary, having type string\r\n  ConditionSummary = 'conditionSummary',\r\n\r\n  // DPI_ConfirmationMsg, having type string\r\n  ConfirmationMsg = 'confirmationMsg',\r\n\r\n  // DPI_DashboardTypeText, having type string\r\n  DashboardTypeText = 'dashboardType',\r\n\r\n  // DPI_DataserverPublicAddress, having type string\r\n  DataserverPublicAddress = 'dataserverPublicAddress',\r\n\r\n  // DPI_DatasourceFileName, having type string\r\n  DatasourceFileName = 'datasourceFileName',\r\n\r\n  // DPI_DecimalMark, having type string\r\n  DecimalMark = 'decimalMark',\r\n\r\n  // DPI_DeleteVariableTooltip, having type string\r\n  DeleteVariableTooltip = 'deleteVariableTooltip',\r\n\r\n  // DPI_DialogTitle, having type string\r\n  DialogTitle = 'dialogTitle',\r\n\r\n  // DPI_DisplayValue, having type string\r\n  DisplayValue = 'displayValue',\r\n\r\n  // DPI_TooltipValue, having type string\r\n  TooltipValue = 'tooltipValue',\r\n\r\n  // DPI_DstPath, having type string\r\n  DstPath = 'dstPath',\r\n\r\n  // DPI_EditWidgetHeader, having type string\r\n  EditWidgetHeader = 'editWidgetHeader',\r\n\r\n  // DPI_EditWidgetInstruction, having type string\r\n  EditWidgetInstruction = 'editWidgetInstruction',\r\n\r\n  // DPI_EndSelectionCaption, having type string\r\n  EndSelectionCaption = 'endSelectionCaption',\r\n\r\n  // DPI_ErrorConfirmationQuestion, having type string\r\n  ErrorConfirmationQuestion = 'errorConfirmationQuestion',\r\n\r\n  // DPI_ErrorDialogTitle, having type string\r\n  ErrorDialogTitle = 'errorDialogTitle',\r\n\r\n  // DPI_ErrorHelpLink, having type string\r\n  ErrorHelpLink = 'errorHelpLink',\r\n\r\n  // DPI_ErrorShortMessage, having type string\r\n  ErrorShortMessage = 'errorShortMessage',\r\n\r\n  // DPI_FilterSearchQuery, having type string\r\n  FilterSearchQuery = 'filterSearchQuery',\r\n\r\n  // DPI_FromLabel, having type string\r\n  FromLabel = 'fromLabel',\r\n\r\n  // DPI_FunctionHelp, having type string\r\n  FunctionHelp = 'functionHelp',\r\n\r\n  // DPI_Instructions, having type string\r\n  Instructions = 'instructions',\r\n\r\n  // DPI_LargeUnitDisplay, having type string\r\n  LargeUnitDisplay = 'largeUnitDisplay',\r\n\r\n  // DPI_Limit, having type string\r\n  Limit = 'limit',\r\n\r\n  // DPI_ListViewNameLabel, having type string\r\n  ListViewNameLabel = 'listViewNameLabel',\r\n\r\n  // DPI_ListViewValueLabel, having type string\r\n  ListViewValueLabel = 'listViewValueLabel',\r\n\r\n  // DPI_MapScaleReadoutUnit, having type string\r\n  MapScaleReadoutUnit = 'mapScaleReadoutUnit',\r\n\r\n  // DPI_MeasureDimension, having type string\r\n  MeasureDimension = 'measuresDimension',\r\n\r\n  // DPI_MimeType, having type string\r\n  MimeType = 'mimeType',\r\n\r\n  // DPI_NotificationMsg, having type string\r\n  NotificationMsg = 'notificationMsg',\r\n\r\n  // DPI_OperationName, having type string\r\n  OperationName = 'operationName',\r\n\r\n  // DPI_PageTitle, having type string\r\n  PageTitle = 'pageTitle',\r\n\r\n  // DPI_PatternSummary, having type string\r\n  PatternSummary = 'patternSummary',\r\n\r\n  // DPI_ReferenceLineId, having type string\r\n  ReferenceLineId = 'refLineId',\r\n\r\n  // DPI_ReferenceLinePairedId, having type string\r\n  ReferenceLinePairedId = 'refLinePairedId',\r\n\r\n  // DPI_ReplaceText, having type string\r\n  ReplaceText = 'replaceText',\r\n\r\n  // DPI_RequiredVariableMessage, having type string\r\n  RequiredVariableMessage = 'requiredVariableMessage',\r\n\r\n  // DPI_RestartEverySpecialCaption, having type string\r\n  RestartEverySpecialCaption = 'restartEverySpecialCaption',\r\n\r\n  // DPI_Root, having type string\r\n  Root = 'root',\r\n\r\n  // DPI_SelectionSummary, having type string\r\n  SelectionSummary = 'selectionSummary',\r\n\r\n  // DPI_SessionAttributeKey, having type string\r\n  SessionAttributeKey = 'sessionAttributeKey',\r\n\r\n  // DPI_SessionAttributeValue, having type string\r\n  SessionAttributeValue = 'sessionAttributeValue',\r\n\r\n  // DPI_SheetAttributeKey, having type string\r\n  SheetAttributeKey = 'baseSheetAttributeKey',\r\n\r\n  // DPI_SheetAttributeValue, having type string\r\n  SheetAttributeValue = 'baseSheetAttributeValue',\r\n\r\n  // DPI_SmallUnitDisplay, having type string\r\n  SmallUnitDisplay = 'smallUnitDisplay',\r\n\r\n  // DPI_SourceCaption, having type string\r\n  SourceCaption = 'sourceCaption',\r\n\r\n  // DPI_SrcPath, having type string\r\n  SrcPath = 'srcPath',\r\n\r\n  // DPI_StartSelectionCaption, having type string\r\n  StartSelectionCaption = 'startSelectionCaption',\r\n\r\n  // DPI_Subtitle, having type string\r\n  Subtitle = 'subtitle',\r\n\r\n  // DPI_TableauServerSiteName, having type string\r\n  TableauServerSiteName = 'tableauServerSiteName',\r\n\r\n  // DPI_TargetCaption, having type string\r\n  TargetCaption = 'targetCaption',\r\n\r\n  // DPI_ThumbnailPath, having type string\r\n  ThumbnailPath = 'thumbnailPath',\r\n\r\n  // DPI_ToLabel, having type string\r\n  ToLabel = 'toLabel',\r\n\r\n  // DPI_URLAddress, having type string\r\n  URLAddress = 'urlAddress',\r\n\r\n  // DPI_UrlRoot, having type string\r\n  UrlRoot = 'urlRoot',\r\n\r\n  // DPI_ValuesTableHeader, having type string\r\n  ValuesTableHeader = 'valuesTableHeader',\r\n\r\n  // DPI_ValuesTableHeader2, having type string\r\n  ValuesTableHeader2 = 'valuesTableHeader2',\r\n\r\n  // DPI_VariableDescription, having type string\r\n  VariableDescription = 'variableDescription',\r\n\r\n  // DPI_VariableDisplayName, having type string\r\n  VariableDisplayName = 'variableDisplayName',\r\n\r\n  // DPI_VariableGUID, having type string\r\n  VariableGUID = 'variableGuid',\r\n\r\n  // DPI_VerboseName, having type string\r\n  VerboseName = 'verboseName',\r\n\r\n  // DPI_ViewId, having type string\r\n  ViewId = 'viewId',\r\n\r\n  // DPI_Warning1, having type string\r\n  Warning1 = 'warning1',\r\n\r\n  // DPI_Warning2, having type string\r\n  Warning2 = 'warning2',\r\n\r\n  // DPI_RefreshToken, having type string\r\n  RefreshToken = 'refresh_token',\r\n\r\n  // DPI_TokenType, having type string\r\n  TokenType = 'token_type',\r\n\r\n  // DPI_XSRFToken, having type string\r\n  XSRFToken = 'xsrf_token',\r\n\r\n  // DPI_AxisSubtitle, having type string\r\n  AxisSubtitle = 'axisSubtitle',\r\n\r\n  // DPI_AxisTitle, having type string\r\n  AxisTitle = 'axisTitle',\r\n\r\n  // DPI_TickMarkOriginDataValue, having type string\r\n  TickMarkOriginDataValue = 'tickMarkOriginDataValue',\r\n\r\n  // DPI_TickMarkOriginDataValueNoTime, having type string\r\n  TickMarkOriginDataValueNoTime = 'tickMarkOriginDataValueNoTime',\r\n\r\n  // DPI_TickMarkSpacingDataValue, having type string\r\n  TickMarkSpacingDataValue = 'tickMarkSpacingDataValue',\r\n\r\n  // DPI_ExtractActionLocalized, having type string\r\n  ExtractActionLocalized = 'extractActionLocalized',\r\n\r\n  // DPI_ExtractSource, having type string\r\n  ExtractSource = 'extractSource',\r\n\r\n  // DPI_FileContents, having type string\r\n  FileContents = 'fileContents',\r\n\r\n  // DPI_SaveImagePath, having type string\r\n  SaveImagePath = 'saveImagePath',\r\n\r\n  // DPI_WidgetUID, having type string\r\n  WidgetUID = 'widgetUniqueId',\r\n\r\n  // DPI_DatePropertiesDisplayText, having type string\r\n  DatePropertiesDisplayText = 'datePropertiesDisplayText',\r\n\r\n  // DPI_DatePropertiesHelperText, having type string\r\n  DatePropertiesHelperText = 'datePropertiesHelperText',\r\n\r\n  // DPI_EventName, having type string\r\n  EventName = 'eventName',\r\n\r\n  // DPI_ExceptionType, having type string\r\n  ExceptionType = 'exceptionType',\r\n\r\n  // DPI_SearchPlaceholder, having type string\r\n  SearchPlaceholder = 'searchPlaceholder',\r\n\r\n  // DPI_TargetVersion, having type string\r\n  TargetVersion = 'targetVersion',\r\n\r\n  // DPI_DataValueDisplayString, having type string\r\n  DataValueDisplayString = 'dataValueDisplayString',\r\n\r\n  // DPI_DomainString, having type string\r\n  DomainString = 'domainString',\r\n\r\n  // DPI_RawDataValueString, having type string\r\n  RawDataValueString = 'rawDataValueString',\r\n\r\n  // DPI_RichTextDialogTitle, having type string\r\n  RichTextDialogTitle = 'richTextDialogTitle',\r\n\r\n  // DPI_RichTextContent, having type string\r\n  RichTextContent = 'richTextContent',\r\n\r\n  // DPI_MarkSizeAsString, having type string\r\n  MarkSizeAsString = 'markSizeAsString',\r\n\r\n  // DPI_UnitsLabel, having type string\r\n  UnitsLabel = 'unitsLabel',\r\n\r\n  // DPI_EmailAddress, having type string\r\n  EmailAddress = 'emailAddress',\r\n\r\n  // DPI_FirstName, having type string\r\n  FirstName = 'firstName',\r\n\r\n  // DPI_LastName, having type string\r\n  LastName = 'lastName',\r\n\r\n  // DPI_SummaryCardAvg, having type string\r\n  SummaryCardAvg = 'summaryCardAvg',\r\n\r\n  // DPI_SummaryCardCaption, having type string\r\n  SummaryCardCaption = 'summaryCardCaption',\r\n\r\n  // DPI_SummaryCardCount, having type string\r\n  SummaryCardCount = 'summaryCardCount',\r\n\r\n  // DPI_SummaryCardKurtosis, having type string\r\n  SummaryCardKurtosis = 'summaryCardKurtosis',\r\n\r\n  // DPI_SummaryCardMax, having type string\r\n  SummaryCardMax = 'summaryCardMax',\r\n\r\n  // DPI_SummaryCardMedian, having type string\r\n  SummaryCardMedian = 'summaryCardMedian',\r\n\r\n  // DPI_SummaryCardMin, having type string\r\n  SummaryCardMin = 'summaryCardMin',\r\n\r\n  // DPI_SummaryCardQuart1, having type string\r\n  SummaryCardQuart1 = 'summaryCardQuart1',\r\n\r\n  // DPI_SummaryCardQuart3, having type string\r\n  SummaryCardQuart3 = 'summaryCardQuart3',\r\n\r\n  // DPI_SummaryCardSkewness, having type string\r\n  SummaryCardSkewness = 'summaryCardSkewness',\r\n\r\n  // DPI_SummaryCardStdev, having type string\r\n  SummaryCardStdev = 'summaryCardStdev',\r\n\r\n  // DPI_SummaryCardSum, having type string\r\n  SummaryCardSum = 'summaryCardSum',\r\n\r\n  // DPI_ValueClassAttr, having type string\r\n  ValueClassAttr = 'valueClassAttr',\r\n\r\n  // DPI_TrendLineDialogTitle, having type string\r\n  TrendLineDialogTitle = 'trendLineDialogTitle',\r\n\r\n  // DPI_LinearFitTypeLabel, having type string\r\n  LinearFitTypeLabel = 'linearFitTypeLabel',\r\n\r\n  // DPI_LogFitTypeLabel, having type string\r\n  LogFitTypeLabel = 'logFitTypeLabel',\r\n\r\n  // DPI_ExpFitTypeLabel, having type string\r\n  ExpFitTypeLabel = 'expFitTypeLabel',\r\n\r\n  // DPI_PowerFitTypeLabel, having type string\r\n  PowerFitTypeLabel = 'powerFitTypeLabel',\r\n\r\n  // DPI_PolynomialFitTypeLabel, having type string\r\n  PolynomialFitTypeLabel = 'polynomialFitTypeLabel',\r\n\r\n  // DPI_ExcludeColorLabel, having type string\r\n  ExcludeColorLabel = 'excludeColorLabel',\r\n\r\n  // DPI_EnableConfidenceBandsLabel, having type string\r\n  EnableConfidenceBandsLabel = 'enableConfidenceBandsLabel',\r\n\r\n  // DPI_ForceInterceptZeroLabel, having type string\r\n  ForceInterceptZeroLabel = 'forceInterceptZero label',\r\n\r\n  // DPI_EnableInstantAnalyticsLabel, having type string\r\n  EnableInstantAnalyticsLabel = 'enableInstantAnalyticsLabel',\r\n\r\n  // DPI_EnableTooltipsLabel, having type string\r\n  EnableTooltipsLabel = 'enableTooltipLabel',\r\n\r\n  // DPI_AuthenticationSummary, having type string\r\n  AuthenticationSummary = 'authenticationSummary',\r\n\r\n  // DPI_BtnCancelText, having type string\r\n  BtnCancelText = 'btnCancelText',\r\n\r\n  // DPI_BtnOkText, having type string\r\n  BtnOkText = 'btnOkText',\r\n\r\n  // DPI_ButtonText, having type string\r\n  ButtonText = 'buttonText',\r\n\r\n  // DPI_CalculationCaption, having type string\r\n  CalculationCaption = 'calculationCaption',\r\n\r\n  // DPI_CalculationDependencies, having type string\r\n  CalculationDependencies = 'calculationDependencies',\r\n\r\n  // DPI_CalculationFormula, having type string\r\n  CalculationFormula = 'calculationFormula',\r\n\r\n  // DPI_CheckPublishMessage, having type string\r\n  CheckPublishMessage = 'checkPublishSummary',\r\n\r\n  // DPI_ClusterModelText, having type string\r\n  ClusterModelText = 'clusterModelText',\r\n\r\n  // DPI_ClusterSummaryScaledText, having type string\r\n  ClusterSummaryScaledText = 'clusterSummaryScaledText',\r\n\r\n  // DPI_ClusterSummaryText, having type string\r\n  ClusterSummaryText = 'clusterSummaryText',\r\n\r\n  // DPI_ColumnCaption, having type string\r\n  ColumnCaption = 'columnCaption',\r\n\r\n  // DPI_DatasourceCaption, having type string\r\n  DatasourceCaption = 'datasourceCaption',\r\n\r\n  // DPI_DefaultCaption, having type string\r\n  DefaultCaption = 'defaultCaption',\r\n\r\n  // DPI_DisplayString, having type string\r\n  DisplayString = 'displayText',\r\n\r\n  // DPI_DragDescription, having type string\r\n  DragDescription = 'dragDescription',\r\n\r\n  // DPI_ExceptionMessage, having type string\r\n  ExceptionMessage = 'exceptionMessage',\r\n\r\n  // DPI_Explanation, having type string\r\n  Explanation = 'explanation',\r\n\r\n  // DPI_FieldCaption, having type string\r\n  FieldCaption = 'fieldCaption',\r\n\r\n  // DPI_FieldSummary, having type string\r\n  FieldSummary = 'fieldSummary',\r\n\r\n  // DPI_FieldSummaryLabel, having type string\r\n  FieldSummaryLabel = 'fieldSummaryLabel',\r\n\r\n  // DPI_FilterDescription, having type string\r\n  FilterDescription = 'filterDescription',\r\n\r\n  // DPI_FilterName, having type string\r\n  FilterName = 'filterName',\r\n\r\n  // DPI_ForecastModelText, having type string\r\n  ForecastModelText = 'forecastModelText',\r\n\r\n  // DPI_ForecastSummaryPctText, having type string\r\n  ForecastSummaryPctText = 'forecastSummaryPctText',\r\n\r\n  // DPI_ForecastSummaryText, having type string\r\n  ForecastSummaryText = 'forecastSummaryText',\r\n\r\n  // DPI_HasActiveExtractText, having type string\r\n  HasActiveExtractText = 'hasActiveExtractText',\r\n\r\n  // DPI_HtmlColor, having type string\r\n  HtmlColor = 'htmlColor',\r\n\r\n  // DPI_IncludeLocalFilesCheckedWarning, having type string\r\n  IncludeLocalFilesCheckedWarning = 'includeLocalFilesCheckedWarning',\r\n\r\n  // DPI_IncludeLocalFilesWarning, having type string\r\n  IncludeLocalFilesWarning = 'includeLocalFilesWarning',\r\n\r\n  // DPI_InvalidFieldCaption, having type string\r\n  InvalidFieldCaption = 'invalidFieldCaption',\r\n\r\n  // DPI_LimitSummary, having type string\r\n  LimitSummary = 'limitSummary',\r\n\r\n  // DPI_LoadedExistingObjectWarning, having type string\r\n  LoadedExistingObjectWarning = 'loadedExistingObjectWarning',\r\n\r\n  // DPI_ManageDatasourcesSummary, having type string\r\n  ManageDatasourcesSummary = 'manageDatasourcesSummary',\r\n\r\n  // DPI_ModalDialog, having type string\r\n  ModalDialog = 'modalDialog',\r\n\r\n  // DPI_NewDatasourceCaption, having type string\r\n  NewDatasourceCaption = 'newDatasourceCaption',\r\n\r\n  // DPI_PermissionsButtonLabel, having type string\r\n  PermissionsButtonLabel = 'permissionsButtonLabel',\r\n\r\n  // DPI_PermissionsEditorRoleId, having type string\r\n  PermissionsEditorRoleId = 'permissionsEditorRoleId',\r\n\r\n  // DPI_PermissionsLabel, having type string\r\n  PermissionsLabel = 'permissionsLabel',\r\n\r\n  // DPI_PerspectiveCaption, having type string\r\n  PerspectiveCaption = 'perspectiveCaption',\r\n\r\n  // DPI_PublishButtonLabel, having type string\r\n  PublishButtonLabel = 'publishButtonLabel',\r\n\r\n  // DPI_PublishChoiceLabel, having type string\r\n  PublishChoiceLabel = 'publishChoiceLabel',\r\n\r\n  // DPI_PublishObjectViewsSummary, having type string\r\n  PublishObjectViewsSummary = 'publishObjectViewsSummary',\r\n\r\n  // DPI_QualifiedFieldCaption, having type string\r\n  QualifiedFieldCaption = 'qualifiedFieldCaption',\r\n\r\n  // DPI_RelationshipTooltipText, having type string\r\n  RelationshipTooltipText = 'relationshipTooltipText',\r\n\r\n  // DPI_ResetObjectAttributesWarning, having type string\r\n  ResetObjectAttributesWarning = 'resetObjectAttributesWarning',\r\n\r\n  // DPI_RowCountCaption, having type string\r\n  RowCountCaption = 'rowCountCaption',\r\n\r\n  // DPI_ServerCaption, having type string\r\n  ServerCaption = 'serverCaption',\r\n\r\n  // DPI_SizeModeName, having type string\r\n  SizeModeName = 'sizeModeName',\r\n\r\n  // DPI_SummaryText, having type string\r\n  SummaryText = 'summaryText',\r\n\r\n  // DPI_SyncClientUseExtractLabel, having type string\r\n  SyncClientUseExtractLabel = 'syncClientUseExtractLabel',\r\n\r\n  // DPI_Text, having type string\r\n  Text = 'text',\r\n\r\n  // DPI_TextDropdownControlLabel, having type string\r\n  TextDropdownControlLabel = 'controlLabel',\r\n\r\n  // DPI_ThumbnailUserName, having type string\r\n  ThumbnailUserName = 'thumbnailUserName',\r\n\r\n  // DPI_TitleString, having type string\r\n  TitleString = 'titleString',\r\n\r\n  // DPI_TooltipText, having type string\r\n  TooltipText = 'tooltipText',\r\n\r\n  // DPI_UpdatedCalcCaption, having type string\r\n  UpdatedCalcCaption = 'updatedCalculationCaption',\r\n\r\n  // DPI_UpdatedCalcFormula, having type string\r\n  UpdatedCalcFormula = 'updatedCalculationFormula',\r\n\r\n  // DPI_UserCaption, having type string\r\n  UserCaption = 'userCaption',\r\n\r\n  // DPI_WarningTooltipText, having type string\r\n  WarningTooltipText = 'warningTooltipText',\r\n\r\n  // DPI_DatasourceFile, having type string\r\n  DatasourceFile = 'datasourceFile',\r\n\r\n  // DPI_File, having type string\r\n  File = 'file',\r\n\r\n  // DPI_FileNameBase, having type string\r\n  FileNameBase = 'filenameBase',\r\n\r\n  // DPI_NewFile, having type string\r\n  NewFile = 'newFile',\r\n\r\n  // DPI_OriginalFile, having type string\r\n  OriginalFile = 'originalFile',\r\n\r\n  // DPI_OutputFile, having type string\r\n  OutputFile = 'outputFile',\r\n\r\n  // DPI_SampleFileName, having type string\r\n  SampleFileName = 'sampleFilename',\r\n\r\n  // DPI_WorkbookFile, having type string\r\n  WorkbookFile = 'workbookFile',\r\n\r\n  // DPI_ImageKey, having type string\r\n  ImageKey = 'imageKey',\r\n\r\n  // DPI_OverlayImageKey, having type string\r\n  OverlayImageKey = 'overlayImageKey',\r\n\r\n  // DPI_TempFileKey, having type string\r\n  TempFileKey = 'tempfileKey',\r\n\r\n  // DPI_CapturedSheet, having type string\r\n  CapturedSheet = 'capturedSheet',\r\n\r\n  // DPI_CurrentSheet, having type string\r\n  CurrentSheet = 'currentSheet',\r\n\r\n  // DPI_Dashboard, having type string\r\n  Dashboard = 'dashboard',\r\n\r\n  // DPI_EnsureSheet, having type string\r\n  EnsureSheet = 'ensureSheetName',\r\n\r\n  // DPI_NewSheet, having type string\r\n  NewSheet = 'newSheet',\r\n\r\n  // DPI_Sheet, having type string\r\n  Sheet = 'sheet',\r\n\r\n  // DPI_SheetName, having type string\r\n  SheetName = 'sheetName',\r\n\r\n  // DPI_SourceDashboard, having type string\r\n  SourceDashboard = 'sourceDashboard',\r\n\r\n  // DPI_SourceSheet, having type string\r\n  SourceSheet = 'sourceSheet',\r\n\r\n  // DPI_TargetSheet, having type string\r\n  TargetSheet = 'targetSheet',\r\n\r\n  // DPI_WorkbookName, having type string\r\n  WorkbookName = 'workbookName',\r\n\r\n  // DPI_Worksheet, having type string\r\n  Worksheet = 'worksheet',\r\n\r\n  // DPI_BaseViewThumbLink, having type string\r\n  BaseViewThumbLink = 'baseViewThumbLink',\r\n\r\n  // DPI_BlogLink, having type string\r\n  BlogLink = 'blogLink',\r\n\r\n  // DPI_CacheUrl, having type string\r\n  CacheUrl = 'cacheUrl',\r\n\r\n  // DPI_DownloadLink, having type string\r\n  DownloadLink = 'downloadLink',\r\n\r\n  // DPI_RepositoryUrl, having type string\r\n  RepositoryUrl = 'repositoryUrl',\r\n\r\n  // DPI_ShareLink, having type string\r\n  ShareLink = 'shareLink',\r\n\r\n  // DPI_URL, having type string\r\n  URL = 'url',\r\n\r\n  // DPI_ClusterModelHtml, having type string\r\n  ClusterModelHtml = 'clusterModelHtml',\r\n\r\n  // DPI_ClusterSummaryHtml, having type string\r\n  ClusterSummaryHtml = 'clusterSummaryHtml',\r\n\r\n  // DPI_ClusterSummaryScaledHtml, having type string\r\n  ClusterSummaryScaledHtml = 'clusterSummaryScaledHtml',\r\n\r\n  // DPI_FieldDescription, having type string\r\n  FieldDescription = 'fieldDescription',\r\n\r\n  // DPI_ForecastModelHtml, having type string\r\n  ForecastModelHtml = 'forecastModelHtml',\r\n\r\n  // DPI_ForecastSummaryHtml, having type string\r\n  ForecastSummaryHtml = 'forecastSummaryHtml',\r\n\r\n  // DPI_ForecastSummaryPctHtml, having type string\r\n  ForecastSummaryPctHtml = 'forecastSummaryPctHtml',\r\n\r\n  // DPI_Html, having type string\r\n  Html = 'html',\r\n\r\n  // DPI_HtmlSelection, having type string\r\n  HtmlSelection = 'htmlSelection',\r\n\r\n  // DPI_HtmlTooltip, having type string\r\n  HtmlTooltip = 'htmlTooltip',\r\n\r\n  // DPI_HtmlTooltipModified, having type string\r\n  HtmlTooltipModified = 'htmlTooltipModified',\r\n\r\n  // DPI_TitleHtml, having type string\r\n  TitleHtml = 'titleHtml',\r\n\r\n  // DPI_CacheUrlInfoJson, having type string\r\n  CacheUrlInfoJson = 'cacheUrlInfoJson',\r\n\r\n  // DPI_FilterSearchJson, having type string\r\n  FilterSearchJson = 'filterSearchJson',\r\n\r\n  // DPI_FilterSearchWithIndexJson, having type string\r\n  FilterSearchWithIndexJson = 'filterSearchWithIndexJson',\r\n\r\n  // DPI_FilterShowChildrenJson, having type string\r\n  FilterShowChildrenJson = 'filterShowChildrenJson',\r\n\r\n  // DPI_FiltersJson, having type string\r\n  FiltersJson = 'filtersJson',\r\n\r\n  // DPI_FrameJson, having type string\r\n  FrameJson = 'frameJson',\r\n\r\n  // DPI_GeometryJson, having type string\r\n  GeometryJson = 'geometryJson',\r\n\r\n  // DPI_GetFilterItemsJson, having type string\r\n  GetFilterItemsJson = 'getFilterItemsJson',\r\n\r\n  // DPI_KeepOnlyResponseJson, having type string\r\n  KeepOnlyResponseJson = 'keepOnlyResponseJson',\r\n\r\n  // DPI_MenuCommandsJson, having type string\r\n  MenuCommandsJson = 'menuCommandsJson',\r\n\r\n  // DPI_ModifiedSheetsJson, having type string\r\n  ModifiedSheetsJson = 'modifiedSheetsJson',\r\n\r\n  // DPI_ParameterCtrlJson, having type string\r\n  ParameterCtrlJson = 'parameterCtrlJson',\r\n\r\n  // DPI_ViewJson, having type string\r\n  ViewJson = 'viewJson',\r\n\r\n  // DPI_CustomizedViewXML, having type string\r\n  CustomizedViewXML = 'customizedViewXml',\r\n\r\n  // DPI_DatasourceDeltaXML, having type string\r\n  DatasourceDeltaXML = 'datasourceDeltaXml',\r\n\r\n  // DPI_DatasourceXML, having type string\r\n  DatasourceXML = 'datasourceXml',\r\n\r\n  // DPI_KeychainXML, having type string\r\n  KeychainXML = 'keychainXml',\r\n\r\n  // DPI_PermissionsModelXML, having type string\r\n  PermissionsModelXML = 'permissionsModelXml',\r\n\r\n  // DPI_SharedViewsXML, having type string\r\n  SharedViewsXML = 'sharedViewsXml',\r\n\r\n  // DPI_TargetURL, having type string\r\n  TargetURL = 'targetUrl',\r\n\r\n  // DPI_Anchor, having type string\r\n  Anchor = 'anchor',\r\n\r\n  // DPI_CenterValue, having type string\r\n  CenterValue = 'centerValue',\r\n\r\n  // DPI_ComputedBinSize, having type string\r\n  ComputedBinSize = 'computedBinSize',\r\n\r\n  // DPI_ConstantValue, having type string\r\n  ConstantValue = 'constantValue',\r\n\r\n  // DPI_PairedConstantValue, having type string\r\n  PairedConstantValue = 'pairedConstantValue',\r\n\r\n  // DPI_CountDistinct, having type string\r\n  CountDistinct = 'countDistinct',\r\n\r\n  // DPI_DataMax, having type string\r\n  DataMax = 'dataMax',\r\n\r\n  // DPI_DataMin, having type string\r\n  DataMin = 'dataMin',\r\n\r\n  // DPI_DataValueString, having type string\r\n  DataValueString = 'dataValueStr',\r\n\r\n  // DPI_EndValue, having type string\r\n  EndValue = 'endValue',\r\n\r\n  // DPI_RangeMax, having type string\r\n  RangeMax = 'rangeMax',\r\n\r\n  // DPI_RangeMin, having type string\r\n  RangeMin = 'rangeMin',\r\n\r\n  // DPI_RangeStepSize, having type string\r\n  RangeStepSize = 'rangeStepSize',\r\n\r\n  // DPI_StartValue, having type string\r\n  StartValue = 'startValue',\r\n\r\n  // DPI_TargetValue, having type string\r\n  TargetValue = 'targetValue',\r\n\r\n  // DPI_ValueInc, having type string\r\n  ValueInc = 'valueInc',\r\n\r\n  // DPI_ValueMax, having type string\r\n  ValueMax = 'valueMax',\r\n\r\n  // DPI_ValueMin, having type string\r\n  ValueMin = 'valueMin',\r\n\r\n  // DPI_QuantilesValue, having type string\r\n  QuantilesValue = 'quantilesValue',\r\n\r\n  // DPI_UserInputBinSize, having type string\r\n  UserInputBinSize = 'userBinSize',\r\n\r\n  // DPI_AddedDataSources, having type string[]\r\n  AddedDataSources = 'addedDataSourceNames',\r\n\r\n  // DPI_AddressingCaptions, having type string[]\r\n  AddressingCaptions = 'addressingCaptions',\r\n\r\n  // DPI_AggregationCaptions, having type string[]\r\n  AggregationCaptions = 'aggregationCaptions',\r\n\r\n  // DPI_AtTheLevelCaptions, having type string[]\r\n  AtTheLevelCaptions = 'atTheLevelCaptions',\r\n\r\n  // DPI_AuthenticationSettingLabels, having type string[]\r\n  AuthenticationSettingLabels = 'authenticationSettingLabels',\r\n\r\n  // DPI_AutosaveFileIdsVector, having type string[]\r\n  AutosaveFileIdsVector = 'autosaveFileIdsVector',\r\n\r\n  // DPI_ChangedTuples, having type string[]\r\n  ChangedTuples = 'changedTuples',\r\n\r\n  // DPI_CharsetsAvailable, having type string[]\r\n  CharsetsAvailable = 'charsetsAvailable',\r\n\r\n  // DPI_CharsetDisplayNames, having type string[]\r\n  CharsetDisplayNames = 'charsetDisplayNames',\r\n\r\n  // DPI_ColorFactors, having type string[]\r\n  ColorFactors = 'colorFactors',\r\n\r\n  // DPI_ColumnFullNames, having type string[]\r\n  ColumnFullNames = 'columnFullNames',\r\n\r\n  // DPI_ConnectionNames, having type string[]\r\n  ConnectionNames = 'connectionNames',\r\n\r\n  // DPI_ConnectionCaptions, having type string[]\r\n  ConnectionCaptions = 'connectionCaptions',\r\n\r\n  // DPI_ConnectionBigQueryLegacySQLCheckBox, having type string[]\r\n  ConnectionBigQueryLegacySQLCheckBox = 'connectionBigqueryLegacySqlCheckbox',\r\n\r\n  // DPI_CustomFieldOrder, having type string[]\r\n  CustomFieldOrder = 'customFieldOrder',\r\n\r\n  // DPI_DataSourceClasses, having type string[]\r\n  DataSourceClasses = 'dataSourceClasses',\r\n\r\n  // DPI_DataSourceNames, having type string[]\r\n  DataSourceNames = 'dataSourceNames',\r\n\r\n  // DPI_DataSourceNames2, having type string[]\r\n  DataSourceNames2 = 'dataSourceNames2',\r\n\r\n  // DPI_DataSourcesWithEmptyRelation, having type string[]\r\n  DataSourcesWithEmptyRelation = 'dataSourcesWithEmptyRelation',\r\n\r\n  // DPI_DataSourceCreationErrors, having type string[]\r\n  DataSourceCreationErrors = 'dataSourceCreationErrors',\r\n\r\n  // DPI_DateFormats, having type string[]\r\n  DateFormats = 'dateFormats',\r\n\r\n  // DPI_DayNames, having type string[]\r\n  DayNames = 'dayNames',\r\n\r\n  // DPI_DrillPathVector, having type string[]\r\n  DrillPathVector = 'drillpathVector',\r\n\r\n  // DPI_ErrorDetails, having type string[]\r\n  ErrorDetails = 'errorDetails',\r\n\r\n  // DPI_ExceptionMessageParams, having type string[]\r\n  ExceptionMessageParams = 'exceptionMessageParams',\r\n\r\n  // DPI_ExcludedSheets, having type string[]\r\n  ExcludedSheets = 'excludeSheets',\r\n\r\n  // DPI_FieldDisplayNames, having type string[]\r\n  FieldDisplayNames = 'fieldDisplayNames',\r\n\r\n  // DPI_FieldFolderVector, having type string[]\r\n  FieldFolderVector = 'fieldFolderVector',\r\n\r\n  // DPI_FileIds, having type string[]\r\n  FileIds = 'fileIds',\r\n\r\n  // DPI_FilePaths, having type string[]\r\n  FilePaths = 'filePaths',\r\n\r\n  // DPI_FileNames, having type string[]\r\n  FileNames = 'fileNames',\r\n\r\n  // DPI_FilterAdd, having type string[]\r\n  FilterAdd = 'filterAdd',\r\n\r\n  // DPI_FilterAliases, having type string[]\r\n  FilterAliases = 'filterValues',\r\n\r\n  // DPI_FilterRemove, having type string[]\r\n  FilterRemove = 'filterRemove',\r\n\r\n  // DPI_FixedCaptions, having type string[]\r\n  FixedCaptions = 'fixedCaptions',\r\n\r\n  // DPI_FontFamilies, having type string[]\r\n  FontFamilies = 'fontFamilies',\r\n\r\n  // DPI_FormatStrings, having type string[]\r\n  FormatStrings = 'formatStrings',\r\n\r\n  // DPI_FormattedValues, having type string[]\r\n  FormattedValues = 'formattedValues',\r\n\r\n  // DPI_FoundTuples, having type string[]\r\n  FoundTuples = 'foundTuples',\r\n\r\n  // DPI_FullSchedulesLabels, having type string[]\r\n  FullSchedulesLabels = 'fullSchedulesLabels',\r\n\r\n  // DPI_ImageResourceList, having type string[]\r\n  ImageResourceList = 'imageResources',\r\n\r\n  // DPI_IncludeList, having type string[]\r\n  IncludeList = 'includeList',\r\n\r\n  // DPI_IncrSchedulesLabels, having type string[]\r\n  IncrSchedulesLabels = 'incrSchedulesLabels',\r\n\r\n  // DPI_InvalidDates, having type string[]\r\n  InvalidDates = 'invalidDates',\r\n\r\n  // DPI_InvalidValues, having type string[]\r\n  InvalidValues = 'invalidValues',\r\n\r\n  // DPI_ItemValues, having type string[]\r\n  ItemValues = 'itemValues',\r\n\r\n  // DPI_JoinEditableProps, having type string[]\r\n  JoinEditableProps = 'joinEditableProps',\r\n\r\n  // DPI_JoinFieldCaptions, having type string[]\r\n  JoinFieldCaptions = 'joinFieldCaptions',\r\n\r\n  // DPI_LocaleOptions, having type string[]\r\n  LocaleOptions = 'localeOptions',\r\n\r\n  // DPI_LocaleDisplayNames, having type string[]\r\n  LocaleDisplayNames = 'localeDisplayNames',\r\n\r\n  // DPI_MapBoxStyleMaps, having type string[]\r\n  MapBoxStyleMaps = 'mapboxStyleMaps',\r\n\r\n  // DPI_MapConnectionErrorDetails, having type string[]\r\n  MapConnectionErrorDetails = 'mapConnectionErrorDetails',\r\n\r\n  // DPI_SheetNames, having type string[]\r\n  SheetNames = 'sheetNames',\r\n\r\n  // DPI_MapSourceNames, having type string[]\r\n  MapSourceNames = 'mapSourceNames',\r\n\r\n  // DPI_MarkGeometries, having type string[]\r\n  MarkGeometries = 'markGeometries',\r\n\r\n  // DPI_MenuItems, having type string[]\r\n  MenuItems = 'menuItems',\r\n\r\n  // DPI_Modes, having type string[]\r\n  Modes = 'modes',\r\n\r\n  // DPI_MonthNames, having type string[]\r\n  MonthNames = 'monthNames',\r\n\r\n  // DPI_NumberFormats, having type string[]\r\n  NumberFormats = 'numberFormats',\r\n\r\n  // DPI_ObjectTextIDs, having type string[]\r\n  ObjectTextIDs = 'objectTextIds',\r\n\r\n  // DPI_OldExtracts, having type string[]\r\n  OldExtracts = 'oldExtracts',\r\n\r\n  // DPI_OrderingTypeCaptions, having type string[]\r\n  OrderingTypeCaptions = 'orderingTypeCaptions',\r\n\r\n  // DPI_PageNames, having type string[]\r\n  PageNames = 'pageNames',\r\n\r\n  // DPI_PaneDescriptorKeys, having type string[]\r\n  PaneDescriptorKeys = 'paneDescriptorKeys',\r\n\r\n  // DPI_ParamCaptions, having type string[]\r\n  ParamCaptions = 'paramCaptions',\r\n\r\n  // DPI_PrecannedDataValues, having type string[]\r\n  PrecannedDataValues = 'precannedDataValues',\r\n\r\n  // DPI_PublishChoiceLabels, having type string[]\r\n  PublishChoiceLabels = 'publishChoiceLabels',\r\n\r\n  // DPI_RankTypeCaptions, having type string[]\r\n  RankTypeCaptions = 'rankTypeCaptions',\r\n\r\n  // DPI_RecentTags, having type string[]\r\n  RecentTags = 'recentTags',\r\n\r\n  // DPI_RelativeCaptions, having type string[]\r\n  RelativeCaptions = 'relativeCaptions',\r\n\r\n  // DPI_RemovedDataSources, having type string[]\r\n  RemovedDataSources = 'removedDataSourceNames',\r\n\r\n  // DPI_RepresentativeTuple, having type string[]\r\n  RepresentativeTuple = 'representativeTuple',\r\n\r\n  // DPI_RestartEveryCaptions, having type string[]\r\n  RestartEveryCaptions = 'restartEveryCaptions',\r\n\r\n  // DPI_SchemaMemberGlobalNames, having type string[]\r\n  SchemaMemberGlobalNames = 'schemaMemberGlobalNames',\r\n\r\n  // DPI_SelectValuesList, having type string[]\r\n  SelectValuesList = 'selectValues',\r\n\r\n  // DPI_SelectionValueList, having type string[]\r\n  SelectionValueList = 'selectionValueList',\r\n\r\n  // DPI_SortAggCaptions, having type string[]\r\n  SortAggCaptions = 'sortAggCaptions',\r\n\r\n  // DPI_SortDirectionCaptions, having type string[]\r\n  SortDirectionCaptions = 'sortDirectionCaptions',\r\n\r\n  // DPI_SortFieldCaptions, having type string[]\r\n  SortFieldCaptions = 'sortFieldCaptions',\r\n\r\n  // DPI_SortFieldNameVector, having type string[]\r\n  SortFieldNameVector = 'sortFieldnameVector',\r\n\r\n  // DPI_SupportedJoinOperators, having type string[]\r\n  SupportedJoinOperators = 'supportedJoinOperators',\r\n\r\n  // DPI_TableCalcTypeCaptions, having type string[]\r\n  TableCalcTypeCaptions = 'tableCalcTypeCaptions',\r\n\r\n  // DPI_Tags, having type string[]\r\n  Tags = 'tags',\r\n\r\n  // DPI_TermVec, having type string[]\r\n  TermVec = 'termVector',\r\n\r\n  // DPI_UIAutomationList, having type string[]\r\n  UIAutomationList = 'uiAutomationList',\r\n\r\n  // DPI_ReferenceLineValidCustomLabelTags, having type string[]\r\n  ReferenceLineValidCustomLabelTags = 'validReferenceLineCustomLabelTags',\r\n\r\n  // DPI_LocalizedKeywords, having type string[]\r\n  LocalizedKeywords = 'localizedKeywords',\r\n\r\n  // DPI_AvailableCalendars, having type string[]\r\n  AvailableCalendars = 'availableCalendars',\r\n\r\n  // DPI_SheetsToBeDeletedOrHidden, having type string[]\r\n  SheetsToBeDeletedOrHidden = 'sheetsToBeDeletedOrHidden',\r\n\r\n  // DPI_AddSheets, having type string[]\r\n  AddSheets = 'addSheets',\r\n\r\n  // DPI_NamesOfSubsheets, having type string[]\r\n  NamesOfSubsheets = 'namesOfSubsheets',\r\n\r\n  // DPI_RemoveSheets, having type string[]\r\n  RemoveSheets = 'removeSheets',\r\n\r\n  // DPI_ScrollOffsetSheets, having type string[]\r\n  ScrollOffsetSheets = 'scrollOffsetSheets',\r\n\r\n  // DPI_Sheets, having type string[]\r\n  Sheets = 'sheets',\r\n\r\n  // DPI_SourceWorksheets, having type string[]\r\n  SourceWorksheets = 'sourceWorksheets',\r\n\r\n  // DPI_TargetExcludes, having type string[]\r\n  TargetExcludes = 'targetExclude',\r\n\r\n  // DPI_TargetWorksheets, having type string[]\r\n  TargetWorksheets = 'targetWorksheets',\r\n\r\n  // DPI_TileURLs, having type string[]\r\n  TileURLs = 'tileUrls',\r\n\r\n  // DPI_Details, having type string[]\r\n  Details = 'details',\r\n\r\n  // DPI_FieldCaptions, having type string[]\r\n  FieldCaptions = 'fieldCaptions',\r\n\r\n  // DPI_HighlightCaptions, having type string[]\r\n  HighlightCaptions = 'highlightCaptions',\r\n\r\n  // DPI_LevelCaptions, having type string[]\r\n  LevelCaptions = 'levelCaptions',\r\n\r\n  // DPI_LevelLeafValues, having type string[]\r\n  LevelLeafValues = 'levelLeafValues',\r\n\r\n  // DPI_SubstitutionVariables, having type string[]\r\n  SubstitutionVariables = 'substitutionVariables',\r\n\r\n  // DPI_SubstitutionVariableValues, having type string[]\r\n  SubstitutionVariableValues = 'substitutionVariableValues',\r\n\r\n  // DPI_HtmlTooltips, having type string[]\r\n  HtmlTooltips = 'htmlTooltips',\r\n\r\n  // DPI_InvalidFields, having type string[]\r\n  InvalidFields = 'invalidFields',\r\n\r\n  // DPI_NamesOfColumns, having type string[]\r\n  NamesOfColumns = 'namesOfColumns',\r\n\r\n  // DPI_NamesOfFields, having type string[]\r\n  NamesOfFields = 'namesOfFields',\r\n\r\n  // DPI_ReferencedDatasources, having type string[]\r\n  ReferencedDatasources = 'referencedDataSourceList',\r\n\r\n  // DPI_CSSAttrs, having type Dictionary(of string)\r\n  CSSAttrs = 'cssAttrs',\r\n\r\n  // DPI_DataSourceMap, having type Dictionary(of string)\r\n  DataSourceMap = 'dataSourceMap',\r\n\r\n  // DPI_EventParameters, having type Dictionary(of string)\r\n  EventParameters = 'eventParameters',\r\n\r\n  // DPI_ExceptionAttrs, having type Dictionary(of string)\r\n  ExceptionAttrs = 'exceptionAttrs',\r\n\r\n  // DPI_InvalidSheetMessage, having type Dictionary(of string)\r\n  InvalidSheetMessage = 'invalidSheetMessages',\r\n\r\n  // DPI_MapBoxDefaultStyle, having type Dictionary(of string)\r\n  MapBoxDefaultStyle = 'mapboxDefaultStyles',\r\n\r\n  // DPI_PaneFormattings, having type Dictionary(of string)\r\n  PaneFormattings = 'paneFormattings',\r\n\r\n  // DPI_SourceNameWithCaption, having type Dictionary(of string)\r\n  SourceNameWithCaption = 'sourceNameWithCaption',\r\n\r\n  // DPI_ConnectionColorMap, having type Dictionary(of string)\r\n  ConnectionColorMap = 'connectionColorMap',\r\n\r\n  // DPI_TargetNameWithCaption, having type Dictionary(of string)\r\n  TargetNameWithCaption = 'targetNameWithCaption',\r\n\r\n  // DPI_ViewIds, having type Dictionary(of string)\r\n  ViewIds = 'viewIds',\r\n\r\n  // DPI_AddInSettings, having type Dictionary(of string)\r\n  AddInSettings = 'addInSettings',\r\n\r\n  // DPI_DatasourceIcons, having type Dictionary(of string)\r\n  DatasourceIcons = 'datasourceIcons',\r\n\r\n  // DPI_FormattedText, having type string\r\n  FormattedText = 'formattedText',\r\n\r\n  // DPI_IconTooltip, having type string\r\n  IconTooltip = 'iconTooltip',\r\n\r\n  // DPI_Title, having type string\r\n  Title = 'title',\r\n\r\n  // DPI_Tooltip, having type string\r\n  Tooltip = 'tooltip',\r\n\r\n  // DPI_ZoneText, having type string\r\n  ZoneText = 'zoneText',\r\n\r\n  // DPI_AlignmentFlags, having type int\r\n  AlignmentFlags = 'alignmentFlags',\r\n\r\n  // DPI_AlphaLevel, having type int\r\n  AlphaLevel = 'alphaLevel',\r\n\r\n  // DPI_AnovaDF, having type int\r\n  AnovaDF = 'anovaDf',\r\n\r\n  // DPI_AtTheLevelIndex, having type int\r\n  AtTheLevelIndex = 'atTheLevelIndex',\r\n\r\n  // DPI_AutomaticDrillIdxInVector, having type int\r\n  AutomaticDrillIdxInVector = 'automaticDrillIdxVector',\r\n\r\n  // DPI_AutoSize, having type int\r\n  AutoSize = 'automaticSize',\r\n\r\n  // DPI_BaseCoord, having type int\r\n  BaseCoord = 'baseCoord',\r\n\r\n  // DPI_CalcEditorCursorPosPostDrop, having type int\r\n  CalcEditorCursorPosPostDrop = 'calcEditorCursorPosPostDrop',\r\n\r\n  // DPI_CalcEditorDropPos, having type int\r\n  CalcEditorDropPos = 'calcEditorDropPos',\r\n\r\n  // DPI_CalcEditorTextSelectionEndPos, having type int\r\n  CalcEditorTextSelectionEndPos = 'calcEditorTextSelectionEndPos',\r\n\r\n  // DPI_CalcEditorTextSelectionStartPos, having type int\r\n  CalcEditorTextSelectionStartPos = 'calcEditorTextSelectionStartPos',\r\n\r\n  // DPI_CategoricalBinId, having type int\r\n  CategoricalBinId = 'categoricalBinId',\r\n\r\n  // DPI_CategoricalFindControllerId, having type int\r\n  CategoricalFindControllerId = 'categoricalFindControllerId',\r\n\r\n  // DPI_ClauseToModifyIndex, having type int\r\n  ClauseToModifyIndex = 'clauseToModifyIndex',\r\n\r\n  // DPI_ClientRenderPixelLimit, having type int\r\n  ClientRenderPixelLimit = 'clientRenderPixelLimit',\r\n\r\n  // DPI_ColCount, having type int\r\n  ColCount = 'colCount',\r\n\r\n  // DPI_ColWidth, having type int\r\n  ColWidth = 'colWidth',\r\n\r\n  // DPI_ColumnLevels, having type int\r\n  ColumnLevels = 'columnLevels',\r\n\r\n  // DPI_ColumnNumber, having type int\r\n  ColumnNumber = 'columnNumber',\r\n\r\n  // DPI_ColumnWidth, having type int\r\n  ColumnWidth = 'columnWidth',\r\n\r\n  // DPI_ContentHeight, having type int\r\n  ContentHeight = 'contentH',\r\n\r\n  // DPI_ContentWidth, having type int\r\n  ContentWidth = 'contentW',\r\n\r\n  // DPI_ContentX, having type int\r\n  ContentX = 'contentX',\r\n\r\n  // DPI_ContentY, having type int\r\n  ContentY = 'contentY',\r\n\r\n  // DPI_Coordinate, having type int\r\n  Coordinate = 'coord',\r\n\r\n  // DPI_CurDateAgg, having type int\r\n  CurDateAgg = 'curDateAgg',\r\n\r\n  // DPI_CurrentCustViewId, having type int\r\n  CurrentCustViewId = 'currentCustomViewId',\r\n\r\n  // DPI_CustomSplitCharacterCountSeparator, having type int\r\n  CustomSplitCharacterCountSeparator = 'customSplitCharacterCountSeparator',\r\n\r\n  // DPI_CustomSplitDesiredSplitCount, having type int\r\n  CustomSplitDesiredSplitCount = 'customSplitDesiredSplitCount',\r\n\r\n  // DPI_DashboardGridSize, having type int\r\n  DashboardGridSize = 'dashboardGridSize',\r\n\r\n  // DPI_DataIndex, having type int\r\n  DataIndex = 'dataIndex',\r\n\r\n  // DPI_DecimalPlaces, having type int\r\n  DecimalPlaces = 'decimalPlaces',\r\n\r\n  // DPI_DeltaTime, having type int\r\n  DeltaTime = 'deltaTime',\r\n\r\n  // DPI_DestPix, having type int\r\n  DestPix = 'destPix',\r\n\r\n  // DPI_DeviceIndex, having type int\r\n  DeviceIndex = 'deviceIndex',\r\n\r\n  // DPI_Duration, having type int\r\n  Duration = 'duration',\r\n\r\n  // DPI_EndPtX, having type int\r\n  EndPtX = 'endX',\r\n\r\n  // DPI_EndPtY, having type int\r\n  EndPtY = 'endY',\r\n\r\n  // DPI_ErrorLen, having type int\r\n  ErrorLen = 'lengthOfCalcOfError',\r\n\r\n  // DPI_ErrorPos, having type int\r\n  ErrorPos = 'startPositionForError',\r\n\r\n  // DPI_ExceptionErrorMessageId, having type int\r\n  ExceptionErrorMessageId = 'exceptionErrorMessageId',\r\n\r\n  // DPI_ExtentsH, having type int\r\n  ExtentsH = 'extentsHeight',\r\n\r\n  // DPI_ExtentsW, having type int\r\n  ExtentsW = 'extentsWidth',\r\n\r\n  // DPI_ExtentsX, having type int\r\n  ExtentsX = 'extentsX',\r\n\r\n  // DPI_ExtentsY, having type int\r\n  ExtentsY = 'extentsY',\r\n\r\n  // DPI_FieldIndex, having type int\r\n  FieldIndex = 'fieldIndex',\r\n\r\n  // DPI_FieldNameId, having type int\r\n  FieldNameId = 'fieldNameId',\r\n\r\n  // DPI_FirstDayOfWeek, having type int\r\n  FirstDayOfWeek = 'firstDayOfWeek',\r\n\r\n  // DPI_FirstLinkedLevel, having type int\r\n  FirstLinkedLevel = 'firstLinkedLevel',\r\n\r\n  // DPI_FirstValueIndex, having type int\r\n  FirstValueIndex = 'firstValueIndex',\r\n\r\n  // DPI_FixedSizePresetIndex, having type int\r\n  FixedSizePresetIndex = 'fixedSizePresetIndex',\r\n\r\n  // DPI_FocusItemIndex, having type int\r\n  FocusItemIndex = 'focusItemIndex',\r\n\r\n  // DPI_FontSize, having type int\r\n  FontSize = 'fontSize',\r\n\r\n  // DPI_ForecastIntRangeEnd, having type int\r\n  ForecastIntRangeEnd = 'forecastIntRangeEnd',\r\n\r\n  // DPI_ForecastIntRangeStart, having type int\r\n  ForecastIntRangeStart = 'forecastIntRangeStart',\r\n\r\n  // DPI_FunctionHelpIndex, having type int\r\n  FunctionHelpIndex = 'functionHelpIndex',\r\n\r\n  // DPI_GeographicSearchMaxResults, having type int\r\n  GeographicSearchMaxResults = 'geographicSearchMaxResults',\r\n\r\n  // DPI_Height, having type int\r\n  Height = 'h',\r\n\r\n  // DPI_HierarchyLevel, having type int\r\n  HierarchyLevel = 'hierarchyLevel',\r\n\r\n  // DPI_HierarchyLevelLoaded, having type int\r\n  HierarchyLevelLoaded = 'hierarchyLevelLoaded',\r\n\r\n  // DPI_HierarchyLevelMinimum, having type int\r\n  HierarchyLevelMinimum = 'hierarchyLevelMinimum',\r\n\r\n  // DPI_HierarchyLoadLimit, having type int\r\n  HierarchyLoadLimit = 'hierarchyLoadLimit',\r\n\r\n  // DPI_HierarchySelectControllerId, having type int\r\n  HierarchySelectControllerId = 'hierarchySelectControllerId',\r\n\r\n  // DPI_HorzTextCell, having type int\r\n  HorzTextCell = 'horzTextCell',\r\n\r\n  // DPI_ImageIndex, having type int\r\n  ImageIndex = 'imageIndex',\r\n\r\n  // DPI_ImageSizeLimit, having type int\r\n  ImageSizeLimit = 'imageSizeLimit',\r\n\r\n  // DPI_TransparentLineMarksLimit, having type int\r\n  TransparentLineMarksLimit = 'transparentLineMarksLimit',\r\n\r\n  // DPI_Indent, having type int\r\n  Indent = 'indent',\r\n\r\n  // DPI_Index, having type int\r\n  Index = 'idx',\r\n\r\n  // DPI_IndexFrom, having type int\r\n  IndexFrom = 'indexFrom',\r\n\r\n  // DPI_IndexOffset, having type int\r\n  IndexOffset = 'indexOffset',\r\n\r\n  // DPI_IndexRelativeDateField, having type int\r\n  IndexRelativeDateField = 'indiexRelativeDateField',\r\n\r\n  // DPI_IndexSelectedItem, having type int\r\n  IndexSelectedItem = 'indexSelectedItem',\r\n\r\n  // DPI_IndexTo, having type int\r\n  IndexTo = 'indexTo',\r\n\r\n  // DPI_InlineConnectionRenameRow, having type int\r\n  InlineConnectionRenameRow = 'inlineConnectionRenameRow',\r\n\r\n  // DPI_InsertPos, having type int\r\n  InsertPos = 'insertPos',\r\n\r\n  // DPI_IsHasDataSupported, having type int\r\n  IsHasDataSupported = 'isHasDataSupported',\r\n\r\n  // DPI_LeftMargin, having type int\r\n  LeftMargin = 'leftMargin',\r\n\r\n  // DPI_LeftRightBorderWidth, having type int\r\n  LeftRightBorderWidth = 'leftRightBorderWidth',\r\n\r\n  // DPI_LevelNumber, having type int\r\n  LevelNumber = 'levelNumber',\r\n\r\n  // DPI_LowerBound, having type int\r\n  LowerBound = 'lowerBound',\r\n\r\n  // DPI_MapRequestPixels, having type int\r\n  MapRequestPixels = 'mapRequestPixels',\r\n\r\n  // DPI_MapScaleFontSizePixels, having type int\r\n  MapScaleFontSizePixels = 'mapScaleFontSizePixels',\r\n\r\n  // DPI_MapScaleReadoutNumber, having type int\r\n  MapScaleReadoutNumber = 'mapScaleReadoutNumber',\r\n\r\n  // DPI_MapScaleWidth, having type int\r\n  MapScaleWidth = 'mapScaleWidth',\r\n\r\n  // DPI_MapTileSize, having type int\r\n  MapTileSize = 'mapTileSize',\r\n\r\n  // DPI_Margin, having type int\r\n  Margin = 'margin',\r\n\r\n  // DPI_MarginBottom, having type int\r\n  MarginBottom = 'marginBottom',\r\n\r\n  // DPI_MarginLeft, having type int\r\n  MarginLeft = 'marginLeft',\r\n\r\n  // DPI_MarginRight, having type int\r\n  MarginRight = 'marginRight',\r\n\r\n  // DPI_MarginTop, having type int\r\n  MarginTop = 'marginTop',\r\n\r\n  // DPI_MaxCell, having type int\r\n  MaxCell = 'maxCell',\r\n\r\n  // DPI_MaxItemSpan, having type int\r\n  MaxItemSpan = 'maxItemSpan',\r\n\r\n  // DPI_MaxPolynomialDegree, having type int\r\n  MaxPolynomialDegree = 'maxDegree',\r\n\r\n  // DPI_MaxPosition, having type int\r\n  MaxPosition = 'maxPosition',\r\n\r\n  // DPI_MaxSize, having type int\r\n  MaxSize = 'maxSize',\r\n\r\n  // DPI_MinCell, having type int\r\n  MinCell = 'minCell',\r\n\r\n  // DPI_MinPolynomialDegree, having type int\r\n  MinPolynomialDegree = 'minDegree',\r\n\r\n  // DPI_MinPosition, having type int\r\n  MinPosition = 'minPosition',\r\n\r\n  // DPI_MinSize, having type int\r\n  MinSize = 'minSize',\r\n\r\n  // DPI_ModelDF, having type int\r\n  ModelDF = 'modelDf',\r\n\r\n  // DPI_NewIndex, having type int\r\n  NewIndex = 'newIndex',\r\n\r\n  // DPI_NumDataSourcesUsingServer, having type int\r\n  NumDataSourcesUsingServer = 'numDataSourcesUsingServer',\r\n\r\n  // DPI_NumFilteredObs, having type int\r\n  NumFilteredObs = 'filteredObservations',\r\n\r\n  // DPI_NumModeledObs, having type int\r\n  NumModeledObs = 'modeledObservations',\r\n\r\n  // DPI_NumNotClustered, having type int\r\n  NumNotClustered = 'numNotClustered',\r\n\r\n  // DPI_NumNumericFields, having type int\r\n  NumNumericFields = 'numNumericFields',\r\n\r\n  // DPI_NumOutliers, having type int\r\n  NumOutliers = 'numOutliers',\r\n\r\n  // DPI_NumRows, having type int\r\n  NumRows = 'numRows',\r\n\r\n  // DPI_NumSelected, having type int\r\n  NumSelected = 'numSelected',\r\n\r\n  // DPI_OffsetX, having type int\r\n  OffsetX = 'offsetX',\r\n\r\n  // DPI_OffsetY, having type int\r\n  OffsetY = 'offsetY',\r\n\r\n  // DPI_Padding, having type int\r\n  Padding = 'padding',\r\n\r\n  // DPI_PaddingBottom, having type int\r\n  PaddingBottom = 'paddingBottom',\r\n\r\n  // DPI_PaddingLeft, having type int\r\n  PaddingLeft = 'paddingLeft',\r\n\r\n  // DPI_PaddingRight, having type int\r\n  PaddingRight = 'paddingRight',\r\n\r\n  // DPI_PaddingTop, having type int\r\n  PaddingTop = 'paddingTop',\r\n\r\n  // DPI_PageLoadPercentage, having type int\r\n  PageLoadPercentage = 'pageLoadPercentage',\r\n\r\n  // DPI_PaletteIndex, having type int\r\n  PaletteIndex = 'paletteIndex',\r\n\r\n  // DPI_PaneSpecificationId, having type int\r\n  PaneSpecificationId = 'paneSpec',\r\n\r\n  // DPI_ParameterCtrlIncrementsPerTick, having type int\r\n  ParameterCtrlIncrementsPerTick = 'parameterControlIncrementMultiplier',\r\n\r\n  // DPI_PolynomialDegree, having type int\r\n  PolynomialDegree = 'degree',\r\n\r\n  // DPI_Port, having type int\r\n  Port = 'datasourcePort',\r\n\r\n  // DPI_Position, having type int\r\n  Position = 'position',\r\n\r\n  // DPI_ParentProjectId, having type int\r\n  ParentProjectId = 'parentProjectId',\r\n\r\n  // DPI_Radius, having type int\r\n  Radius = 'radius',\r\n\r\n  // DPI_ReadoutOffset, having type int\r\n  ReadoutOffset = 'readoutOffset',\r\n\r\n  // DPI_ReferenceIndex, having type int\r\n  ReferenceIndex = 'referenceIndex',\r\n\r\n  // DPI_RegionHeight, having type int\r\n  RegionHeight = 'regionHeight',\r\n\r\n  // DPI_RegionWidth, having type int\r\n  RegionWidth = 'regionWidth',\r\n\r\n  // DPI_RemovedDatasourceCount, having type int\r\n  RemovedDatasourceCount = 'removedDatasourceCount',\r\n\r\n  // DPI_RemovedSheetCount, having type int\r\n  RemovedSheetCount = 'removedSheetCount',\r\n\r\n  // DPI_ResidualDF, having type int\r\n  ResidualDF = 'residualDf',\r\n\r\n  // DPI_ResizeColumn, having type int\r\n  ResizeColumn = 'resizeColumn',\r\n\r\n  // DPI_RestartEveryIndex, having type int\r\n  RestartEveryIndex = 'restartEveryIndex',\r\n\r\n  // DPI_RightMargin, having type int\r\n  RightMargin = 'rightMargin',\r\n\r\n  // DPI_RowCount, having type int\r\n  RowCount = 'rowCount',\r\n\r\n  // DPI_RowHeight, having type int\r\n  RowHeight = 'rowHeight',\r\n\r\n  // DPI_RowInnerLevels, having type int\r\n  RowInnerLevels = 'rowInnerLevels',\r\n\r\n  // DPI_RowLevels, having type int\r\n  RowLevels = 'rowLevels',\r\n\r\n  // DPI_RowNumber, having type int\r\n  RowNumber = 'rowNumber',\r\n\r\n  // DPI_RowWidth, having type int\r\n  RowWidth = 'rowWidth',\r\n\r\n  // DPI_SecondLinkedLevel, having type int\r\n  SecondLinkedLevel = 'secondLinkedLevel',\r\n\r\n  // DPI_SecondValueIndex, having type int\r\n  SecondValueIndex = 'secondValueIndex',\r\n\r\n  // DPI_SecondsAgo, having type int\r\n  SecondsAgo = 'secondsAgo',\r\n\r\n  // DPI_SelectionEnd, having type int\r\n  SelectionEnd = 'selectionEnd',\r\n\r\n  // DPI_SelectionStart, having type int\r\n  SelectionStart = 'selectionStart',\r\n\r\n  // DPI_ShapePaletteID, having type int\r\n  ShapePaletteID = 'shapePaletteId',\r\n\r\n  // DPI_SheetIndex, having type int\r\n  SheetIndex = 'sheetIndex',\r\n\r\n  // DPI_ShelfPositionIndex, having type int\r\n  ShelfPositionIndex = 'shelfPosIndex',\r\n\r\n  // DPI_Size, having type int\r\n  Size = 'size',\r\n\r\n  // DPI_SizeDifference, having type int\r\n  SizeDifference = 'sizeDelta',\r\n\r\n  // DPI_SnapDistance, having type int\r\n  SnapDistance = 'snapDistance',\r\n\r\n  // DPI_SnapLocation, having type int\r\n  SnapLocation = 'snapLocation',\r\n\r\n  // DPI_SolveOrder, having type int\r\n  SolveOrder = 'solveOrder',\r\n\r\n  // DPI_SpaceBetweenPoints, having type int\r\n  SpaceBetweenPoints = 'spaceBetweenPoints',\r\n\r\n  // DPI_StepSize, having type int\r\n  StepSize = 'stepSize',\r\n\r\n  // DPI_Steps, having type int\r\n  Steps = 'steps',\r\n\r\n  // DPI_StoryPointIndex, having type int\r\n  StoryPointIndex = 'currentStorypointIndex',\r\n\r\n  // DPI_StyleLen, having type int\r\n  StyleLen = 'tokenLengthForStyle',\r\n\r\n  // DPI_StylePos, having type int\r\n  StylePos = 'tokenPositionForStyle',\r\n\r\n  // DPI_SwatchAreaWidth, having type int\r\n  SwatchAreaWidth = 'swatchWidth',\r\n\r\n  // DPI_TargetBinId, having type int\r\n  TargetBinId = 'targetBinId',\r\n\r\n  // DPI_TargetPtX, having type int\r\n  TargetPtX = 'targetX',\r\n\r\n  // DPI_TargetPtY, having type int\r\n  TargetPtY = 'targetY',\r\n\r\n  // DPI_TileFactor, having type int\r\n  TileFactor = 'tileFactor',\r\n\r\n  // DPI_TitleHeight, having type int\r\n  TitleHeight = 'titleHeight',\r\n\r\n  // DPI_TitleWidth, having type int\r\n  TitleWidth = 'titleWidth',\r\n\r\n  // DPI_TopBottomBorderWidth, having type int\r\n  TopBottomBorderWidth = 'topBottomBorderWidth',\r\n\r\n  // DPI_UIAutomationLineSize, having type int\r\n  UIAutomationLineSize = 'uiAutomationLineSize',\r\n\r\n  // DPI_UIAutomationPageSize, having type int\r\n  UIAutomationPageSize = 'uiAutomationPageSize',\r\n\r\n  // DPI_UID, having type int\r\n  UID = 'uid',\r\n\r\n  // DPI_UpperBound, having type int\r\n  UpperBound = 'upperBound',\r\n\r\n  // DPI_VertTextCell, having type int\r\n  VertTextCell = 'vertTextCell',\r\n\r\n  // DPI_Width, having type int\r\n  Width = 'w',\r\n\r\n  // DPI_X, having type int\r\n  X = 'x',\r\n\r\n  // DPI_Y, having type int\r\n  Y = 'y',\r\n\r\n  // DPI_ZOrder, having type int\r\n  ZOrder = 'zOrder',\r\n\r\n  // DPI_ZoneIconIndex, having type int\r\n  ZoneIconIndex = 'zoneIconIndex',\r\n\r\n  // DPI_AliasIndices, having type int[]\r\n  AliasIndices = 'aliasIndices',\r\n\r\n  // DPI_AnovaDFVec, having type int[]\r\n  AnovaDFVec = 'anovaDfVector',\r\n\r\n  // DPI_ColumnIndices, having type int[]\r\n  ColumnIndices = 'columnIndices',\r\n\r\n  // DPI_DrillFieldIndices, having type int[]\r\n  DrillFieldIndices = 'drillFieldIndices',\r\n\r\n  // DPI_FilterMaxIndices, having type int[]\r\n  FilterMaxIndices = 'filterMaxIndices',\r\n\r\n  // DPI_FilterMinIndices, having type int[]\r\n  FilterMinIndices = 'filterMinIndices',\r\n\r\n  // DPI_FilterValuesIndices, having type int[]\r\n  FilterValuesIndices = 'filterValueIndices',\r\n\r\n  // DPI_FormatStringIndices, having type int[]\r\n  FormatStringIndices = 'formatstrIndices',\r\n\r\n  // DPI_FormattedValIndices, having type int[]\r\n  FormattedValIndices = 'formatValIdxs',\r\n\r\n  // DPI_PaletteIndices, having type int[]\r\n  PaletteIndices = 'palettesIndices',\r\n\r\n  // DPI_PaneIndices, having type int[]\r\n  PaneIndices = 'paneIndices',\r\n\r\n  // DPI_Points, having type int[]\r\n  Points = 'points',\r\n\r\n  // DPI_QuickFilterSettings, having type int[]\r\n  QuickFilterSettings = 'quickFilterSettings',\r\n\r\n  // DPI_SelectedIndices, having type int[]\r\n  SelectedIndices = 'selectedIndices',\r\n\r\n  // DPI_ShelfPositionIndices, having type int[]\r\n  ShelfPositionIndices = 'shelfPosIndices',\r\n\r\n  // DPI_TileBox, having type int[]\r\n  TileBox = 'tileBox',\r\n\r\n  // DPI_TrailOverride, having type int[]\r\n  TrailOverride = 'trailOverride',\r\n\r\n  // DPI_UIDs, having type int[]\r\n  UIDs = 'uids',\r\n\r\n  // DPI_ValueIndices, having type int[]\r\n  ValueIndices = 'valueIndices',\r\n\r\n  // DPI_XCellOffsets, having type int[]\r\n  XCellOffsets = 'xCellOffsets',\r\n\r\n  // DPI_XPixelOffsets, having type int[]\r\n  XPixelOffsets = 'xPixelOffsets',\r\n\r\n  // DPI_YCellOffsets, having type int[]\r\n  YCellOffsets = 'yCellOffsets',\r\n\r\n  // DPI_YPixelOffsets, having type int[]\r\n  YPixelOffsets = 'yPixelOffsets',\r\n\r\n  // DPI_IntMap, having type Dictionary(of int)\r\n  IntMap = 'intMap',\r\n\r\n  // DPI_SelectedAuthSettingIndices, having type Dictionary(of int)\r\n  SelectedAuthSettingIndices = 'selectedAuthSettingIndices',\r\n\r\n  // DPI_ActiveStoryPointID, having type uint\r\n  ActiveStoryPointID = 'activeStoryPointId',\r\n\r\n  // DPI_ActiveZoneID, having type uint\r\n  ActiveZoneID = 'activeZoneId',\r\n\r\n  // DPI_ActualSize, having type uint\r\n  ActualSize = 'actualSize',\r\n\r\n  // DPI_AddInDebugPort, having type uint\r\n  AddInDebugPort = 'addInDebugPort',\r\n\r\n  // DPI_AggregationIndex, having type uint\r\n  AggregationIndex = 'aggregationIndex',\r\n\r\n  // DPI_AnnotationID, having type uint\r\n  AnnotationID = 'annotationId',\r\n\r\n  // DPI_AssignedAliasCount, having type uint\r\n  AssignedAliasCount = 'assignedAliasCount',\r\n\r\n  // DPI_CapabilityId, having type uint\r\n  CapabilityId = 'capabilityId',\r\n\r\n  // DPI_CaretIndex, having type uint\r\n  CaretIndex = 'caretIndex',\r\n\r\n  // DPI_CellID, having type uint\r\n  CellID = 'cellId',\r\n\r\n  // DPI_ColumnIndex, having type uint\r\n  ColumnIndex = 'columnIndex',\r\n\r\n  // DPI_CommandID, having type uint\r\n  CommandID = 'id',\r\n\r\n  // DPI_CommandIndex, having type uint\r\n  CommandIndex = 'index',\r\n\r\n  // DPI_ControllerId, having type uint\r\n  ControllerId = 'controllerId',\r\n\r\n  // DPI_Count, having type uint\r\n  Count = 'count',\r\n\r\n  // DPI_URowCount, having type uint\r\n  URowCount = 'uRowCount',\r\n\r\n  // DPI_UColumnCount, having type uint\r\n  UColumnCount = 'uColumnCount',\r\n\r\n  // DPI_CurrentPage, having type uint\r\n  CurrentPage = 'currentPage',\r\n\r\n  // DPI_DatePeriodsCount, having type uint\r\n  DatePeriodsCount = 'datePeriodsCount',\r\n\r\n  // DPI_Decimals, having type uint\r\n  Decimals = 'decimals',\r\n\r\n  // DPI_DefaultHeight, having type uint\r\n  DefaultHeight = 'defaultHeight',\r\n\r\n  // DPI_DefaultItem, having type uint\r\n  DefaultItem = 'defaultItem',\r\n\r\n  // DPI_DefaultWidth, having type uint\r\n  DefaultWidth = 'defaultWidth',\r\n\r\n  // DPI_Depth, having type uint\r\n  Depth = 'depth',\r\n\r\n  // DPI_DetailID, having type uint\r\n  DetailID = 'detailId',\r\n\r\n  // DPI_DrillLevel, having type uint\r\n  DrillLevel = 'drillLevel',\r\n\r\n  // DPI_DuplicateIndex, having type uint\r\n  DuplicateIndex = 'duplicateIndex',\r\n\r\n  // DPI_EndIndex, having type uint\r\n  EndIndex = 'endIndex',\r\n\r\n  // DPI_FieldIconIdx, having type uint\r\n  FieldIconIdx = 'fieldIconIdx',\r\n\r\n  // DPI_FilterLevel, having type uint\r\n  FilterLevel = 'filterLevel',\r\n\r\n  // DPI_FilterTileSize, having type uint\r\n  FilterTileSize = 'filterTileSize',\r\n\r\n  // DPI_FiscalYearStart, having type uint\r\n  FiscalYearStart = 'fiscalYearStart',\r\n\r\n  // DPI_FitPagesAcross, having type uint\r\n  FitPagesAcross = 'pageFitHorizontal',\r\n\r\n  // DPI_FitPagesDown, having type uint\r\n  FitPagesDown = 'pageFitVertical',\r\n\r\n  // DPI_FixedIndex, having type uint\r\n  FixedIndex = 'fixedIndex',\r\n\r\n  // DPI_FlipboardZoneID, having type uint\r\n  FlipboardZoneID = 'flipboardZoneId',\r\n\r\n  // DPI_ForecastAutoRangeSize, having type uint\r\n  ForecastAutoRangeSize = 'forecastAutoRangeSize',\r\n\r\n  // DPI_ForecastEndOfRange, having type uint\r\n  ForecastEndOfRange = 'forecastEndOfRange',\r\n\r\n  // DPI_ForecastIgnoreLast, having type uint\r\n  ForecastIgnoreLast = 'forecastIgnoreLast',\r\n\r\n  // DPI_ForecastNextRangeSize, having type uint\r\n  ForecastNextRangeSize = 'forecastNextRangeSize',\r\n\r\n  // DPI_GroupFlags, having type uint\r\n  GroupFlags = 'groupFlag',\r\n\r\n  // DPI_HierarchyLevels, having type uint\r\n  HierarchyLevels = 'hierarchyLevels',\r\n\r\n  // DPI_HierarchyMemberId, having type uint\r\n  HierarchyMemberId = 'hierarchyMemberId',\r\n\r\n  // DPI_HitTestFlags, having type uint\r\n  HitTestFlags = 'hitTestFlags',\r\n\r\n  // DPI_ImageHeight, having type uint\r\n  ImageHeight = 'imageHeight',\r\n\r\n  // DPI_ImageWidth, having type uint\r\n  ImageWidth = 'imageWidth',\r\n\r\n  // DPI_ItemIndex, having type uint\r\n  ItemIndex = 'itemIndex',\r\n\r\n  // DPI_ItemIndex1, having type uint\r\n  ItemIndex1 = 'itemIndex1',\r\n\r\n  // DPI_LineHeight, having type uint\r\n  LineHeight = 'lineHeight',\r\n\r\n  // DPI_MapIntermediateLevels, having type uint\r\n  MapIntermediateLevels = 'mapIntermediateLevels',\r\n\r\n  // DPI_MapWorldRepeats, having type uint\r\n  MapWorldRepeats = 'mapWorldRepeats',\r\n\r\n  // DPI_MaxAlpha, having type uint\r\n  MaxAlpha = 'maxAlpha',\r\n\r\n  // DPI_MaxHeight, having type uint\r\n  MaxHeight = 'maxHeight',\r\n\r\n  // DPI_MaxNumberWebListItems, having type uint\r\n  MaxNumberWebListItems = 'maxNumberWebListItems',\r\n\r\n  // DPI_MaxPrevOrNextValues, having type uint\r\n  MaxPrevOrNextValues = 'maxPrevOrNextValues',\r\n\r\n  // DPI_MaxRows, having type uint\r\n  MaxRows = 'maxRows',\r\n\r\n  // DPI_MaxTransparency, having type uint\r\n  MaxTransparency = 'colorMaxTransparencyValue',\r\n\r\n  // DPI_MaxWidth, having type uint\r\n  MaxWidth = 'maxWidth',\r\n\r\n  // DPI_MinColumns, having type uint\r\n  MinColumns = 'minColumns',\r\n\r\n  // DPI_MinHeight, having type uint\r\n  MinHeight = 'minHeight',\r\n\r\n  // DPI_MinPrevOrNextValues, having type uint\r\n  MinPrevOrNextValues = 'minPrevOrNextValues',\r\n\r\n  // DPI_MinTransparency, having type uint\r\n  MinTransparency = 'colorMinTransparencyValue',\r\n\r\n  // DPI_MinWidth, having type uint\r\n  MinWidth = 'minWidth',\r\n\r\n  // DPI_NestedCalcsIndex, having type uint\r\n  NestedCalcsIndex = 'nestedCalcsIndex',\r\n\r\n  // DPI_NextValues, having type uint\r\n  NextValues = 'nextValues',\r\n\r\n  // DPI_NodeLevel, having type uint\r\n  NodeLevel = 'nodeLevel',\r\n\r\n  // DPI_NumHighlighted, having type uint\r\n  NumHighlighted = 'numHighlighted',\r\n\r\n  // DPI_NumberOfNextValues, having type uint\r\n  NumberOfNextValues = 'numberOfNextValues',\r\n\r\n  // DPI_NumberOfPrevValues, having type uint\r\n  NumberOfPrevValues = 'numberOfPrevValues',\r\n\r\n  // DPI_ObjectID, having type uint\r\n  ObjectID = 'objectId',\r\n\r\n  // DPI_OrderingTypeIndex, having type uint\r\n  OrderingTypeIndex = 'orderingTypeIndex',\r\n\r\n  // DPI_PageCount, having type uint\r\n  PageCount = 'pageCount',\r\n\r\n  // DPI_PageFadeEnd, having type uint\r\n  PageFadeEnd = 'fadeEnd',\r\n\r\n  // DPI_PageFadeStart, having type uint\r\n  PageFadeStart = 'fadeStart',\r\n\r\n  // DPI_PageIndex, having type uint\r\n  PageIndex = 'pageIndex',\r\n\r\n  // DPI_PageNumber, having type uint\r\n  PageNumber = 'pageNumber',\r\n\r\n  // DPI_PageScalePercent, having type uint\r\n  PageScalePercent = 'pageScalePercent',\r\n\r\n  // DPI_PageTrailLength, having type uint\r\n  PageTrailLength = 'historyLength',\r\n\r\n  // DPI_PaletteFlagsVal, having type uint\r\n  PaletteFlagsVal = 'paletteFlagsVal',\r\n\r\n  // DPI_PaneIndex, having type uint\r\n  PaneIndex = 'paneIndex',\r\n\r\n  // DPI_ParamCtrlDisplayFlags, having type uint\r\n  ParamCtrlDisplayFlags = 'paramDisplayFlags',\r\n\r\n  // DPI_ParentZoneID, having type uint\r\n  ParentZoneID = 'parentZoneId',\r\n\r\n  // DPI_PercentileParam, having type uint\r\n  PercentileParam = 'percentileParam',\r\n\r\n  // DPI_PrevValues, having type uint\r\n  PrevValues = 'prevValues',\r\n\r\n  // DPI_PublishResultStringId, having type uint\r\n  PublishResultStringId = 'publishResultStringId',\r\n\r\n  // DPI_QRGBColor, having type uint\r\n  QRGBColor = 'qrgbColor',\r\n\r\n  // DPI_RangeN, having type uint\r\n  RangeN = 'rangeN',\r\n\r\n  // DPI_RankTypeIndex, having type uint\r\n  RankTypeIndex = 'rankTypeIndex',\r\n\r\n  // DPI_RenderComplexity, having type uint\r\n  RenderComplexity = 'renderComplexityLimit',\r\n\r\n  // DPI_RowIndex, having type uint\r\n  RowIndex = 'rowIndex',\r\n\r\n  // DPI_SelectedAuthSettingIndex, having type uint\r\n  SelectedAuthSettingIndex = 'selectedAuthSettingIndex',\r\n\r\n  // DPI_SelectedFullScheduleIndex, having type uint\r\n  SelectedFullScheduleIndex = 'selectedFullScheduleIndex',\r\n\r\n  // DPI_SelectedIncrScheduleIndex, having type uint\r\n  SelectedIncrScheduleIndex = 'selectedIncrScheduleIndex',\r\n\r\n  // DPI_SelectedPublishChoiceIndex, having type uint\r\n  SelectedPublishChoiceIndex = 'selectedPublishChoiceIndex',\r\n\r\n  // DPI_SelectedMemberCount, having type uint\r\n  SelectedMemberCount = 'selectedMemberCount',\r\n\r\n  // DPI_ShapeID, having type uint\r\n  ShapeID = 'shapeId',\r\n\r\n  // DPI_SheetUseCount, having type uint\r\n  SheetUseCount = 'useCount',\r\n\r\n  // DPI_ShelfItemID, having type uint\r\n  ShelfItemID = 'shelfItemId',\r\n\r\n  // DPI_SigFigs, having type uint\r\n  SigFigs = 'sigFigs',\r\n\r\n  // DPI_SortAggIndex, having type uint\r\n  SortAggIndex = 'sortAggIndvValues',\r\n\r\n  // DPI_SortColumnIndex, having type uint\r\n  SortColumnIndex = 'sortColumnIndex',\r\n\r\n  // DPI_SortDirectionIndex, having type uint\r\n  SortDirectionIndex = 'sortDirectionIndex',\r\n\r\n  // DPI_SortFieldIndex, having type uint\r\n  SortFieldIndex = 'sortFieldIndex',\r\n\r\n  // DPI_StartIndex, having type uint\r\n  StartIndex = 'startIndex',\r\n\r\n  // DPI_StartOfWeek, having type uint\r\n  StartOfWeek = 'startOfWeek',\r\n\r\n  // DPI_StoreId, having type uint\r\n  StoreId = 'storeId',\r\n\r\n  // DPI_StoryPointID, having type uint\r\n  StoryPointID = 'storyPointId',\r\n\r\n  // DPI_TableCalcTypeIndex, having type uint\r\n  TableCalcTypeIndex = 'tableCalcTypeIndex',\r\n\r\n  // DPI_TableCalcTypesUsed, having type uint\r\n  TableCalcTypesUsed = 'tableCalcTypesUsed',\r\n\r\n  // DPI_TemplateIndex, having type uint\r\n  TemplateIndex = 'templateIndex',\r\n\r\n  // DPI_TileCount, having type uint\r\n  TileCount = 'tileCount',\r\n\r\n  // DPI_TimeoutSeconds, having type uint\r\n  TimeoutSeconds = 'timeoutSeconds',\r\n\r\n  // DPI_TopN, having type uint\r\n  TopN = 'topN',\r\n\r\n  // DPI_TotalNumberOfItemsInSet, having type uint\r\n  TotalNumberOfItemsInSet = 'totalNumberOfItemsInSet',\r\n\r\n  // DPI_TotalMemberCount, having type uint\r\n  TotalMemberCount = 'totalMemberCount',\r\n\r\n  // DPI_Transparency, having type uint\r\n  Transparency = 'colorTransparencyValue',\r\n\r\n  // DPI_TupleID, having type uint\r\n  TupleID = 'tupleId',\r\n\r\n  // DPI_UIndex, having type uint\r\n  UIndex = 'uindex',\r\n\r\n  // DPI_UndoPosition, having type uint\r\n  UndoPosition = 'undoPosition',\r\n\r\n  // DPI_UnsignedWidth, having type uint\r\n  UnsignedWidth = 'uw',\r\n\r\n  // DPI_UnsignedWidthBottom, having type uint\r\n  UnsignedWidthBottom = 'uwb',\r\n\r\n  // DPI_UnsignedWidthLeft, having type uint\r\n  UnsignedWidthLeft = 'uwl',\r\n\r\n  // DPI_UnsignedWidthRight, having type uint\r\n  UnsignedWidthRight = 'uwr',\r\n\r\n  // DPI_UnsignedWidthTop, having type uint\r\n  UnsignedWidthTop = 'uwt',\r\n\r\n  // DPI_ValueIndex, having type uint\r\n  ValueIndex = 'valueIndex',\r\n\r\n  // DPI_ValueInt, having type uint\r\n  ValueInt = 'valueInt',\r\n\r\n  // DPI_WorldOffset, having type uint\r\n  WorldOffset = 'worldOffset',\r\n\r\n  // DPI_XDuplicateIndex, having type uint\r\n  XDuplicateIndex = 'xDuplicateIndex',\r\n\r\n  // DPI_XIndex, having type uint\r\n  XIndex = 'xIndex',\r\n\r\n  // DPI_YDuplicateIndex, having type uint\r\n  YDuplicateIndex = 'yDuplicateIndex',\r\n\r\n  // DPI_YIndex, having type uint\r\n  YIndex = 'yIndex',\r\n\r\n  // DPI_ZoneID, having type uint\r\n  ZoneID = 'zoneId',\r\n\r\n  // DPI_ZoneZOrder, having type uint\r\n  ZoneZOrder = 'zoneZOrder',\r\n\r\n  // DPI_ComponentID, having type uint\r\n  ComponentID = 'componentId',\r\n\r\n  // DPI_NonThreadPoolUseCount, having type uint\r\n  NonThreadPoolUseCount = 'nonThreadPoolUseCount',\r\n\r\n  // DPI_AddressingIndices, having type uint[]\r\n  AddressingIndices = 'addressingIndices',\r\n\r\n  // DPI_AddressingInvalidIndices, having type uint[]\r\n  AddressingInvalidIndices = 'addressingInvalidIndices',\r\n\r\n  // DPI_ChildZoneIds, having type uint[]\r\n  ChildZoneIds = 'childZoneIds',\r\n\r\n  // DPI_ColorList, having type uint[]\r\n  ColorList = 'colorList',\r\n\r\n  // DPI_DuplicateIndices, having type uint[]\r\n  DuplicateIndices = 'duplicateIndices',\r\n\r\n  // DPI_FilterAddIndices, having type uint[]\r\n  FilterAddIndices = 'filterAddIndices',\r\n\r\n  // DPI_FilterIndices, having type uint[]\r\n  FilterIndices = 'filterIndices',\r\n\r\n  // DPI_FilterLevelAdd, having type uint[]\r\n  FilterLevelAdd = 'filterLevelAdd',\r\n\r\n  // DPI_FilterLevelRemove, having type uint[]\r\n  FilterLevelRemove = 'filterLevelRemove',\r\n\r\n  // DPI_FilterLevels, having type uint[]\r\n  FilterLevels = 'filterLevels',\r\n\r\n  // DPI_FilterRemoveIndices, having type uint[]\r\n  FilterRemoveIndices = 'filterRemoveIndices',\r\n\r\n  // DPI_FixedValues, having type uint[]\r\n  FixedValues = 'fixedValues',\r\n\r\n  // DPI_HierarchyMemberIdList, having type uint[]\r\n  HierarchyMemberIdList = 'hierarchyMemberIdList',\r\n\r\n  // DPI_InvalidIndices, having type uint[]\r\n  InvalidIndices = 'invalidIndices',\r\n\r\n  // DPI_ItemIndices, having type uint[]\r\n  ItemIndices = 'itemIndices',\r\n\r\n  // DPI_LineTupleIDs, having type uint[]\r\n  LineTupleIDs = 'lineTupleIds',\r\n\r\n  // DPI_ObjectIDs, having type uint[]\r\n  ObjectIDs = 'objectIds',\r\n\r\n  // DPI_PageIndices, having type uint[]\r\n  PageIndices = 'pageIndices',\r\n\r\n  // DPI_QRGB, having type uint[]\r\n  QRGB = 'qrgbList',\r\n\r\n  // DPI_QRGBColors, having type uint[]\r\n  QRGBColors = 'qrgbColors',\r\n\r\n  // DPI_RefLineID, having type uint[]\r\n  RefLineID = 'reflineId',\r\n\r\n  // DPI_ShapeIDs, having type uint[]\r\n  ShapeIDs = 'shapeIds',\r\n\r\n  // DPI_ShelfSelection, having type uint[]\r\n  ShelfSelection = 'shelfSelection',\r\n\r\n  // DPI_StoryPointIDs, having type uint[]\r\n  StoryPointIDs = 'storyPointIds',\r\n\r\n  // DPI_TupleIDs, having type uint[]\r\n  TupleIDs = 'tupleIds',\r\n\r\n  // DPI_Widths, having type uint[]\r\n  Widths = 'widths',\r\n\r\n  // DPI_UintMap, having type Dictionary(of uint32_t)\r\n  UintMap = 'uintMap',\r\n\r\n  // DPI_Alpha, having type float\r\n  Alpha = 'alpha',\r\n\r\n  // DPI_Angle, having type float\r\n  Angle = 'angle',\r\n\r\n  // DPI_BreakPointValue, having type float\r\n  BreakPointValue = 'breakPointValue',\r\n\r\n  // DPI_DevicePixelRatio, having type float\r\n  DevicePixelRatio = 'devicePixelRatio',\r\n\r\n  // DPI_Distance, having type float\r\n  Distance = 'distance',\r\n\r\n  // DPI_FloatX, having type float\r\n  FloatX = 'floatX',\r\n\r\n  // DPI_FloatY, having type float\r\n  FloatY = 'floatY',\r\n\r\n  // DPI_FogDesaturation, having type float\r\n  FogDesaturation = 'fogDesaturation',\r\n\r\n  // DPI_MarkScale, having type float\r\n  MarkScale = 'markScale',\r\n\r\n  // DPI_MarkSizeInPixelUnits, having type float\r\n  MarkSizeInPixelUnits = 'markSizeInPixelUnits',\r\n\r\n  // DPI_PointSize, having type float\r\n  PointSize = 'pointSize',\r\n\r\n  // DPI_StrokeWidth, having type float\r\n  StrokeWidth = 'strokeWidth',\r\n\r\n  // DPI_TextRegionOrientation, having type float\r\n  TextRegionOrientation = 'orientation',\r\n\r\n  // DPI_TransformAngle, having type float\r\n  TransformAngle = 'transformAngle',\r\n\r\n  // DPI_ZoomLevel, having type float\r\n  ZoomLevel = 'zoomLevel',\r\n\r\n  // DPI_OldZoomLevel, having type float\r\n  OldZoomLevel = 'oldZoomLevel',\r\n\r\n  // DPI_NewZoomLevel, having type float\r\n  NewZoomLevel = 'newZoomLevel',\r\n\r\n  // DPI_AspectRatio, having type float\r\n  AspectRatio = 'aspectRatio',\r\n\r\n  // DPI_BottomPrintMargin, having type float\r\n  BottomPrintMargin = 'bottomPrintMargin',\r\n\r\n  // DPI_EarthRadius, having type float\r\n  EarthRadius = 'earthRadius',\r\n\r\n  // DPI_FloatHeight, having type float\r\n  FloatHeight = 'floatHeight',\r\n\r\n  // DPI_FloatLeft, having type float\r\n  FloatLeft = 'floatLeft',\r\n\r\n  // DPI_FloatRadius, having type float\r\n  FloatRadius = 'floatRadius',\r\n\r\n  // DPI_FloatTop, having type float\r\n  FloatTop = 'floatTop',\r\n\r\n  // DPI_FloatWidth, having type float\r\n  FloatWidth = 'floatWidth',\r\n\r\n  // DPI_LeftPrintMargin, having type float\r\n  LeftPrintMargin = 'leftPrintMargin',\r\n\r\n  // DPI_MapCenterLatitude, having type float\r\n  MapCenterLatitude = 'mapCenterLatitude',\r\n\r\n  // DPI_MapCenterLongitude, having type float\r\n  MapCenterLongitude = 'mapCenterLongitude',\r\n\r\n  // DPI_MapDisplayScale, having type float\r\n  MapDisplayScale = 'mapDisplayScale',\r\n\r\n  // DPI_MapMaxStretch, having type float\r\n  MapMaxStretch = 'mapMaxStretch',\r\n\r\n  // DPI_MapMaxZoom, having type float\r\n  MapMaxZoom = 'mapMaxZoom',\r\n\r\n  // DPI_MapMinShrink, having type float\r\n  MapMinShrink = 'mapMinShrink',\r\n\r\n  // DPI_MapMinZoom, having type float\r\n  MapMinZoom = 'mapMinZoom',\r\n\r\n  // DPI_MapRequestZoom, having type float\r\n  MapRequestZoom = 'mapRequestZoom',\r\n\r\n  // DPI_MapWashout, having type float\r\n  MapWashout = 'mapWashout',\r\n\r\n  // DPI_MaxLatitude, having type float\r\n  MaxLatitude = 'maxLatitude',\r\n\r\n  // DPI_MaxLongitude, having type float\r\n  MaxLongitude = 'maxLongitude',\r\n\r\n  // DPI_MinLatitude, having type float\r\n  MinLatitude = 'minLatitude',\r\n\r\n  // DPI_MinLongitude, having type float\r\n  MinLongitude = 'minLongitude',\r\n\r\n  // DPI_RightPrintMargin, having type float\r\n  RightPrintMargin = 'rightPrintMargin',\r\n\r\n  // DPI_TopPrintMargin, having type float\r\n  TopPrintMargin = 'topPrintMargin',\r\n\r\n  // DPI_UIAutomationMaximum, having type float\r\n  UIAutomationMaximum = 'uiAutomationMaximum',\r\n\r\n  // DPI_UIAutomationMinimum, having type float\r\n  UIAutomationMinimum = 'uiAutomationMinimum',\r\n\r\n  // DPI_UIAutomationOffset, having type float\r\n  UIAutomationOffset = 'uiAutomationOffset',\r\n\r\n  // DPI_UnitDivisor, having type float\r\n  UnitDivisor = 'unitDivisor',\r\n\r\n  // DPI_UnitTransition, having type float\r\n  UnitTransition = 'unitTransition',\r\n\r\n  // DPI_AutomaticDrillIdx, having type float[]\r\n  AutomaticDrillIdx = 'automaticDrillIdx',\r\n\r\n  // DPI_DestinationBox, having type float[]\r\n  DestinationBox = 'destBox',\r\n\r\n  // DPI_LowerEnd, having type float[]\r\n  LowerEnd = 'lowerEnd',\r\n\r\n  // DPI_OppositeAxis, having type float[]\r\n  OppositeAxis = 'oppositeAxis',\r\n\r\n  // DPI_PointsF, having type float[]\r\n  PointsF = 'pointsF',\r\n\r\n  // DPI_SourceBox, having type float[]\r\n  SourceBox = 'sourceBox',\r\n\r\n  // DPI_TransformOffset, having type float[]\r\n  TransformOffset = 'transformOffset',\r\n\r\n  // DPI_TransformScale, having type float[]\r\n  TransformScale = 'transformScale',\r\n\r\n  // DPI_UpperEnd, having type float[]\r\n  UpperEnd = 'upperEnd',\r\n\r\n  // DPI_FloatMap, having type Dictionary(of float)\r\n  FloatMap = 'floatMap',\r\n\r\n  // DPI_BGSS, having type double\r\n  BGSS = 'betweenGroupSumOfSquares',\r\n\r\n  // DPI_ConfidenceLevel, having type double\r\n  ConfidenceLevel = 'confidenceLevel',\r\n\r\n  // DPI_ConfidencePercentage, having type double\r\n  ConfidencePercentage = 'confidencePercentage',\r\n\r\n  // DPI_DoubleLeft, having type double\r\n  DoubleLeft = 'doubleLeft',\r\n\r\n  // DPI_DoubleTop, having type double\r\n  DoubleTop = 'doubleTop',\r\n\r\n  // DPI_DoubleValue, having type double\r\n  DoubleValue = 'doubleValue',\r\n\r\n  // DPI_DoubleX, having type double\r\n  DoubleX = 'doubleX',\r\n\r\n  // DPI_DoubleY, having type double\r\n  DoubleY = 'doubleY',\r\n\r\n  // DPI_FStatistic, having type double\r\n  FStatistic = 'fStatistic',\r\n\r\n  // DPI_FilterRangeMax, having type double\r\n  FilterRangeMax = 'filterRangeMax',\r\n\r\n  // DPI_FilterRangeMin, having type double\r\n  FilterRangeMin = 'filterRangeMin',\r\n\r\n  // DPI_GeographicSearchCandidateScore, having type double\r\n  GeographicSearchCandidateScore = 'geographicSearchCandidateScore',\r\n\r\n  // DPI_HeightD, having type double\r\n  HeightD = 'height',\r\n\r\n  // DPI_InflectionFraction, having type double\r\n  InflectionFraction = 'inflectionFraction',\r\n\r\n  // DPI_InflectionValue, having type double\r\n  InflectionValue = 'inflectionValue',\r\n\r\n  // DPI_MSE, having type double\r\n  MSE = 'meanSquaredError',\r\n\r\n  // DPI_MSM, having type double\r\n  MSM = 'meanSquaredModel',\r\n\r\n  // DPI_MapScaleMarginOfError, having type double\r\n  MapScaleMarginOfError = 'mapScaleMarginOfError',\r\n\r\n  // DPI_MarkSize, having type double\r\n  MarkSize = 'markSize',\r\n\r\n  // DPI_MaxMarkSize, having type double\r\n  MaxMarkSize = 'maxMarkSize',\r\n\r\n  // DPI_MinMarkSize, having type double\r\n  MinMarkSize = 'minMarkSize',\r\n\r\n  // DPI_NotchPosition, having type double\r\n  NotchPosition = 'notchPosition',\r\n\r\n  // DPI_NotchValue, having type double\r\n  NotchValue = 'notchValue',\r\n\r\n  // DPI_PValue, having type double\r\n  PValue = 'pValue',\r\n\r\n  // DPI_PercentDimensions, having type double\r\n  PercentDimensions = 'percentDimensions',\r\n\r\n  // DPI_PercentGroups, having type double\r\n  PercentGroups = 'percentGroups',\r\n\r\n  // DPI_PercentMeasures, having type double\r\n  PercentMeasures = 'percentMeasures',\r\n\r\n  // DPI_RSquared, having type double\r\n  RSquared = 'rSquared',\r\n\r\n  // DPI_SSE, having type double\r\n  SSE = 'sumSquaredError',\r\n\r\n  // DPI_SSM, having type double\r\n  SSM = 'sumSquaredModel',\r\n\r\n  // DPI_StandardError, having type double\r\n  StandardError = 'standardError',\r\n\r\n  // DPI_TSS, having type double\r\n  TSS = 'totalSumOfSquares',\r\n\r\n  // DPI_WGSS, having type double\r\n  WGSS = 'withinGroupSumOfSquares',\r\n\r\n  // DPI_WidthD, having type double\r\n  WidthD = 'width',\r\n\r\n  // DPI_ZoomFactor, having type double\r\n  ZoomFactor = 'zoomFactor',\r\n\r\n  // DPI_CoefficientPValueVec, having type double[]\r\n  CoefficientPValueVec = 'coefficientPValueVector',\r\n\r\n  // DPI_CoefficientStdErrVec, having type double[]\r\n  CoefficientStdErrVec = 'coefficientStdErrorVector',\r\n\r\n  // DPI_CoefficientTValueVec, having type double[]\r\n  CoefficientTValueVec = 'coefficientTValueVector',\r\n\r\n  // DPI_CoefficientVec, having type double[]\r\n  CoefficientVec = 'coefficientVector',\r\n\r\n  // DPI_FStatisticVec, having type double[]\r\n  FStatisticVec = 'trendLineFStatisticVector',\r\n\r\n  // DPI_Factors, having type double[]\r\n  Factors = 'factors',\r\n\r\n  // DPI_MSEVec, having type double[]\r\n  MSEVec = 'meanSquaredErrorVector',\r\n\r\n  // DPI_Means, having type double[]\r\n  Means = 'means',\r\n\r\n  // DPI_PValueVec, having type double[]\r\n  PValueVec = 'pValueVector',\r\n\r\n  // DPI_Percentages, having type double[]\r\n  Percentages = 'percentages',\r\n\r\n  // DPI_Percentiles, having type double[]\r\n  Percentiles = 'percentiles',\r\n\r\n  // DPI_SSEVec, having type double[]\r\n  SSEVec = 'sumSquaredErrorVector',\r\n\r\n  // DPI_StDevs, having type double[]\r\n  StDevs = 'stdev',\r\n\r\n  // DPI_UnscaledMeans, having type double[]\r\n  UnscaledMeans = 'unscaledMeans',\r\n\r\n  // DPI_DeltaTimeMs, having type long\r\n  DeltaTimeMs = 'deltaTimeMs',\r\n\r\n  // DPI_ExtractHistoryRowCount, having type long\r\n  ExtractHistoryRowCount = 'extractRowCount',\r\n\r\n  // DPI_ExtractHistoryRowsRemoved, having type long\r\n  ExtractHistoryRowsRemoved = 'extractRowsRemoved',\r\n\r\n  // DPI_ExtractsSize, having type long\r\n  ExtractsSize = 'extractsSize',\r\n\r\n  // DPI_OldExtractSize, having type long\r\n  OldExtractSize = 'oldExtractSize',\r\n\r\n  // DPI_RowsInserted, having type long\r\n  RowsInserted = 'rowsInserted',\r\n\r\n  // DPI_SampleSize, having type long\r\n  SampleSize = 'sampleSize',\r\n\r\n  // DPI_SampleSpace, having type long\r\n  SampleSpace = 'sampleSpace',\r\n\r\n  // DPI_ThreadPoolUseCount, having type long\r\n  ThreadPoolUseCount = 'threadPoolUseCount',\r\n\r\n  // DPI_ActionId, having type string\r\n  ActionId = 'actionId',\r\n\r\n  // DPI_AxisColumn, having type string\r\n  AxisColumn = 'axisColumn',\r\n\r\n  // DPI_BaseColumnName, having type string\r\n  BaseColumnName = 'baseColumnName',\r\n\r\n  // DPI_BreakPointFieldName, having type string\r\n  BreakPointFieldName = 'breakPointFieldName',\r\n\r\n  // DPI_PairedFieldName, having type string\r\n  PairedFieldName = 'pairedFn',\r\n\r\n  // DPI_FieldNameAllowEmpty, having type string\r\n  FieldNameAllowEmpty = 'fieldNameAllowEmpty',\r\n\r\n  // DPI_FieldNameDisAgg, having type string\r\n  FieldNameDisAgg = 'fnDisagg',\r\n\r\n  // DPI_FieldNameLocal, having type string\r\n  FieldNameLocal = 'fieldNameLocal',\r\n\r\n  // DPI_FieldNamePrev, having type string\r\n  FieldNamePrev = 'fnPrev',\r\n\r\n  // DPI_FieldNameSource, having type string\r\n  FieldNameSource = 'fnSource',\r\n\r\n  // DPI_FieldNameTarget, having type string\r\n  FieldNameTarget = 'fnTarget',\r\n\r\n  // DPI_FieldNameX, having type string\r\n  FieldNameX = 'fnX',\r\n\r\n  // DPI_FieldNameY, having type string\r\n  FieldNameY = 'fnY',\r\n\r\n  // DPI_FieldToSort, having type string\r\n  FieldToSort = 'fieldToSort',\r\n\r\n  // DPI_GlobalFieldName, having type string\r\n  GlobalFieldName = 'globalFieldName',\r\n\r\n  // DPI_HierarchyName, having type string\r\n  HierarchyName = 'hierarchyName',\r\n\r\n  // DPI_InvalidAggFieldName, having type string\r\n  InvalidAggFieldName = 'invalidAggFieldName',\r\n\r\n  // DPI_InvalidFieldName, having type string\r\n  InvalidFieldName = 'invalidFieldName',\r\n\r\n  // DPI_LimitParameterName, having type string\r\n  LimitParameterName = 'limitParameterName',\r\n\r\n  // DPI_LocalBaseColumnName, having type string\r\n  LocalBaseColumnName = 'localBaseColumnName',\r\n\r\n  // DPI_MeasureName, having type string\r\n  MeasureName = 'measureName',\r\n\r\n  // DPI_NestedCalcField, having type string\r\n  NestedCalcField = 'nestedCalcFn',\r\n\r\n  // DPI_ParameterName, having type string\r\n  ParameterName = 'parameterName',\r\n\r\n  // DPI_ReferenceParam, having type string\r\n  ReferenceParam = 'referenceParam',\r\n\r\n  // DPI_ReplacementFieldName, having type string\r\n  ReplacementFieldName = 'replacementFieldName',\r\n\r\n  // DPI_RHSTableAlias, having type string\r\n  RHSTableAlias = 'rhsTableAlias',\r\n\r\n  // DPI_SortMeasureName, having type string\r\n  SortMeasureName = 'sortMeasureName',\r\n\r\n  // DPI_UniqueName, having type string\r\n  UniqueName = 'uniqueName',\r\n\r\n  // DPI_ValueColumn, having type string\r\n  ValueColumn = 'valueColumn',\r\n\r\n  // DPI_PairedValueColumn, having type string\r\n  PairedValueColumn = 'pairedValueColumn',\r\n\r\n  // DPI_ActionIds, having type string[]\r\n  ActionIds = 'actionIds',\r\n\r\n  // DPI_AddressingValues, having type string[]\r\n  AddressingValues = 'addressingValues',\r\n\r\n  // DPI_AllColumns, having type string[]\r\n  AllColumns = 'allColumns',\r\n\r\n  // DPI_AtTheLevelValues, having type string[]\r\n  AtTheLevelValues = 'atTheLevelValues',\r\n\r\n  // DPI_AutomaticDrillFieldName, having type string[]\r\n  AutomaticDrillFieldName = 'automaticDrillFieldName',\r\n\r\n  // DPI_BlendingFieldCandidates, having type string[]\r\n  BlendingFieldCandidates = 'blendingFieldCandidates',\r\n\r\n  // DPI_Columns, having type string[]\r\n  Columns = 'columns',\r\n\r\n  // DPI_CurrentBlendingFields, having type string[]\r\n  CurrentBlendingFields = 'currentBlendingFields',\r\n\r\n  // DPI_DimensionsToSort, having type string[]\r\n  DimensionsToSort = 'dimensionsToSort',\r\n\r\n  // DPI_DrillFieldVector, having type string[]\r\n  DrillFieldVector = 'drillFieldVector',\r\n\r\n  // DPI_EncodingFieldVector, having type string[]\r\n  EncodingFieldVector = 'encodingFieldVector',\r\n\r\n  // DPI_FieldVector, having type string[]\r\n  FieldVector = 'fieldVector',\r\n\r\n  // DPI_FilterFields, having type string[]\r\n  FilterFields = 'filterFields',\r\n\r\n  // DPI_LODFieldVector, having type string[]\r\n  LODFieldVector = 'lodFieldVector',\r\n\r\n  // DPI_LegendColumns, having type string[]\r\n  LegendColumns = 'legendColumns',\r\n\r\n  // DPI_LegendNames, having type string[]\r\n  LegendNames = 'legendNames',\r\n\r\n  // DPI_NodeColumns, having type string[]\r\n  NodeColumns = 'nodeColumns',\r\n\r\n  // DPI_PageFields, having type string[]\r\n  PageFields = 'pageFields',\r\n\r\n  // DPI_ParamValues, having type string[]\r\n  ParamValues = 'paramValues',\r\n\r\n  // DPI_RefLineFields, having type string[]\r\n  RefLineFields = 'reflineFields',\r\n\r\n  // DPI_ReferencedColumns, having type string[]\r\n  ReferencedColumns = 'referencedColumns',\r\n\r\n  // DPI_RelatedFieldNames, having type string[]\r\n  RelatedFieldNames = 'relatedFieldNames',\r\n\r\n  // DPI_RemoveActionResults, having type string[]\r\n  RemoveActionResults = 'removeActionResults',\r\n\r\n  // DPI_ResponseVector, having type string[]\r\n  ResponseVector = 'responseVector',\r\n\r\n  // DPI_RestartEveryValues, having type string[]\r\n  RestartEveryValues = 'restartEveryValues',\r\n\r\n  // DPI_ResultFields, having type string[]\r\n  ResultFields = 'resultFields',\r\n\r\n  // DPI_SortFieldValues, having type string[]\r\n  SortFieldValues = 'sortFieldValues',\r\n\r\n  // DPI_XFields, having type string[]\r\n  XFields = 'xFields',\r\n\r\n  // DPI_YFields, having type string[]\r\n  YFields = 'yFields',\r\n\r\n  // DPI_ConnectionFullName, having type string\r\n  ConnectionFullName = 'connectionFullName',\r\n\r\n  // DPI_ConnectionFullNames, having type string[]\r\n  ConnectionFullNames = 'connectionFullNames',\r\n\r\n  // DPI_BoundDataValue, having type object\r\n  BoundDataValue = 'boundDataValue',\r\n\r\n  // DPI_DataValue, having type object\r\n  DataValue = 'dataValue',\r\n\r\n  // DPI_DataValueIncrement, having type object\r\n  DataValueIncrement = 'dataValueIncrement',\r\n\r\n  // DPI_DataValueLowerX, having type object\r\n  DataValueLowerX = 'dataValueLowerX',\r\n\r\n  // DPI_DataValueLowerY, having type object\r\n  DataValueLowerY = 'dataValueLowerY',\r\n\r\n  // DPI_DataValueUpperX, having type object\r\n  DataValueUpperX = 'dataValueUpperX',\r\n\r\n  // DPI_DataValueUpperY, having type object\r\n  DataValueUpperY = 'dataValueUpperY',\r\n\r\n  // DPI_DefaultDataValue, having type object\r\n  DefaultDataValue = 'defaultDataValue',\r\n\r\n  // DPI_MaxDataValue, having type object\r\n  MaxDataValue = 'maxDataValue',\r\n\r\n  // DPI_MinDataValue, having type object\r\n  MinDataValue = 'minDataValue',\r\n\r\n  // DPI_ValidatedDataValue, having type object\r\n  ValidatedDataValue = 'validatedDataValue',\r\n\r\n  // DPI_BinSize, having type object\r\n  BinSize = 'binSize',\r\n\r\n  // DPI_LimitCount, having type object\r\n  LimitCount = 'limitCount',\r\n\r\n  // DPI_DataValueList, having type object[]\r\n  DataValueList = 'dataValueList',\r\n\r\n  // DPI_FieldDisplayItem, having type FieldDisplayItemPresModel\r\n  FieldDisplayItem = 'fieldDisplayItem',\r\n\r\n  // DPI_FieldDisplayList, having type FieldDisplayItemPresModel[]\r\n  FieldDisplayList = 'fieldDisplayList',\r\n\r\n  // DPI_FieldCaptionPair, having type FieldCaptionPairPresModel\r\n  FieldCaptionPair = 'fieldCaptionPair',\r\n\r\n  // DPI_FieldCaptionPairs, having type FieldCaptionPairPresModel[]\r\n  FieldCaptionPairs = 'fieldCaptionPairs',\r\n\r\n  // DPI_ParameterCaptionPairs, having type FieldCaptionPairPresModel[]\r\n  ParameterCaptionPairs = 'parameterCaptionPairs',\r\n\r\n  // DPI_VaryingAttributeDimensions, having type FieldCaptionPairPresModel[]\r\n  VaryingAttributeDimensions = 'varyingAttributeDimensions',\r\n\r\n  // DPI_FieldCaptionPairState, having type FieldCaptionPairStatePresModel\r\n  FieldCaptionPairState = 'fieldCaptionPairState',\r\n\r\n  // DPI_FieldCaptionPairStates, having type FieldCaptionPairStatePresModel[]\r\n  FieldCaptionPairStates = 'fieldCaptionPairStates',\r\n\r\n  // DPI_DatasourceCaptionPair, having type DatasourceCaptionPairPresModel\r\n  DatasourceCaptionPair = 'datasourceCaptionPair',\r\n\r\n  // DPI_DatasourceCaptionPairs, having type DatasourceCaptionPairPresModel[]\r\n  DatasourceCaptionPairs = 'datasourceCaptionPairs',\r\n\r\n  // DPI_SheetNameInfoPair, having type SheetNameInfoPairPresModel\r\n  SheetNameInfoPair = 'sheetNameInfoPair',\r\n\r\n  // DPI_SheetNameInfoPairs, having type SheetNameInfoPairPresModel[]\r\n  SheetNameInfoPairs = 'sheetNameInfoPairs',\r\n\r\n  // DPI_BGActiveColor, having type string\r\n  BGActiveColor = 'bgActiveColor',\r\n\r\n  // DPI_BGColor, having type string\r\n  BGColor = 'bgColor',\r\n\r\n  // DPI_BGRestColor, having type string\r\n  BGRestColor = 'bgRestColor',\r\n\r\n  // DPI_BorderColor, having type string\r\n  BorderColor = 'borderColor',\r\n\r\n  // DPI_BorderColorBottom, having type string\r\n  BorderColorBottom = 'borderColorBottom',\r\n\r\n  // DPI_BorderColorLeft, having type string\r\n  BorderColorLeft = 'borderColorLeft',\r\n\r\n  // DPI_BorderColorRight, having type string\r\n  BorderColorRight = 'borderColorRight',\r\n\r\n  // DPI_BorderColorTop, having type string\r\n  BorderColorTop = 'borderColorTop',\r\n\r\n  // DPI_ButtonObjectBackgroundColor, having type string\r\n  ButtonObjectBackgroundColor = 'buttonObjectBackgroundColor',\r\n\r\n  // DPI_Color, having type string\r\n  Color = 'color',\r\n\r\n  // DPI_Color1, having type string\r\n  Color1 = 'color1',\r\n\r\n  // DPI_Color2, having type string\r\n  Color2 = 'color2',\r\n\r\n  // DPI_DefaultColor, having type string\r\n  DefaultColor = 'defaultColor',\r\n\r\n  // DPI_DistanceFontColor, having type string\r\n  DistanceFontColor = 'distanceFontColor',\r\n\r\n  // DPI_FillColor, having type string\r\n  FillColor = 'fillColor',\r\n\r\n  // DPI_FogColor, having type string\r\n  FogColor = 'fogColor',\r\n\r\n  // DPI_HeaderColor, having type string\r\n  HeaderColor = 'headerColor',\r\n\r\n  // DPI_HighlightBGColor, having type string\r\n  HighlightBGColor = 'highlightBgColor',\r\n\r\n  // DPI_HighlightTextColor, having type string\r\n  HighlightTextColor = 'highlightTextColor',\r\n\r\n  // DPI_HoverColor, having type string\r\n  HoverColor = 'hoverColor',\r\n\r\n  // DPI_HyperlinkColor, having type string\r\n  HyperlinkColor = 'hyperlinkColor',\r\n\r\n  // DPI_MapAttributionFill, having type string\r\n  MapAttributionFill = 'mapAttributionFill',\r\n\r\n  // DPI_MapAttributionTextColor, having type string\r\n  MapAttributionTextColor = 'mapAttributionTextColor',\r\n\r\n  // DPI_MapPaneBackgroundFill, having type string\r\n  MapPaneBackgroundFill = 'mapPaneBackgroundFill',\r\n\r\n  // DPI_MapScaleBorderColor, having type string\r\n  MapScaleBorderColor = 'mapScaleBorderColor',\r\n\r\n  // DPI_MapScaleColor, having type string\r\n  MapScaleColor = 'mapScaleColor',\r\n\r\n  // DPI_MapWaitTileFill, having type string\r\n  MapWaitTileFill = 'mapWaitTileFill',\r\n\r\n  // DPI_MarkColor, having type string\r\n  MarkColor = 'markColor',\r\n\r\n  // DPI_NavArrowDisabledColor, having type string\r\n  NavArrowDisabledColor = 'navArrowDisabledColor',\r\n\r\n  // DPI_NavArrowHoverColor, having type string\r\n  NavArrowHoverColor = 'navArrowHoverColor',\r\n\r\n  // DPI_NavArrowIdleColor, having type string\r\n  NavArrowIdleColor = 'navArrowIdleColor',\r\n\r\n  // DPI_NavArrowPressedColor, having type string\r\n  NavArrowPressedColor = 'navArrowPressedColor',\r\n\r\n  // DPI_PaneColor, having type string\r\n  PaneColor = 'paneColor',\r\n\r\n  // DPI_PressColor, having type string\r\n  PressColor = 'pressColor',\r\n\r\n  // DPI_ResizeBorderColor, having type string\r\n  ResizeBorderColor = 'resizeBorderColor',\r\n\r\n  // DPI_SelectBGColor, having type string\r\n  SelectBGColor = 'selectBgColor',\r\n\r\n  // DPI_SelectionTextColor, having type string\r\n  SelectionTextColor = 'selectionTextColor',\r\n\r\n  // DPI_SwatchBackgroundColor, having type string\r\n  SwatchBackgroundColor = 'swatchBgColor',\r\n\r\n  // DPI_SwatchBorderColor, having type string\r\n  SwatchBorderColor = 'swatchBorderColor',\r\n\r\n  // DPI_TabColor, having type string\r\n  TabColor = 'tabColor',\r\n\r\n  // DPI_Colors, having type string[]\r\n  Colors = 'colors',\r\n\r\n  // DPI_ColorMap, having type Dictionary(of string)\r\n  ColorMap = 'colorMap',\r\n\r\n  // DPI_Pixmap, having type string\r\n  Pixmap = 'pixmap',\r\n\r\n  // DPI_Image, having type string\r\n  Image = 'image',\r\n\r\n  // DPI_OverlayImage, having type string\r\n  OverlayImage = 'overlayImage',\r\n\r\n  // DPI_IconImage, having type string\r\n  IconImage = 'iconImage',\r\n\r\n  // DPI_ImageList, having type string[]\r\n  ImageList = 'imageList',\r\n\r\n  // DPI_ImageMap, having type Dictionary(of string)\r\n  ImageMap = 'imageMap',\r\n\r\n  // DPI_UUID, having type object\r\n  UUID = 'uuid',\r\n\r\n  // DPI_DashboardObjectHandle, having type object\r\n  DashboardObjectHandle = 'dashboardObjectHandle',\r\n\r\n  // DPI_DashboardObjectNewStateHandle, having type object\r\n  DashboardObjectNewStateHandle = 'dashboardObjectNewStateHandle',\r\n\r\n  // DPI_DashboardObjectCurrentStateHandle, having type object\r\n  DashboardObjectCurrentStateHandle = 'dashboardObjectCurrentStateHandle',\r\n\r\n  // DPI_Nanoseconds, having type object\r\n  Nanoseconds = 'nanoseconds',\r\n\r\n  // DPI_Microseconds, having type object\r\n  Microseconds = 'microseconds',\r\n\r\n  // DPI_Milliseconds, having type object\r\n  Milliseconds = 'milliseconds',\r\n\r\n  // DPI_TimeoutS, having type object\r\n  TimeoutS = 'timeoutS',\r\n\r\n  // DPI_Minutes, having type object\r\n  Minutes = 'minutes',\r\n\r\n  // DPI_Hours, having type object\r\n  Hours = 'hours',\r\n\r\n  // DPI_CardType, having type CardType\r\n  CardType = 'cardType',\r\n\r\n  // DPI_DocParameterID, having type string\r\n  DocParameterID = 'type',\r\n\r\n  // DPI_ArgumentParam, having type string\r\n  ArgumentParam = 'argumentParam',\r\n\r\n  // DPI_ArgumentParams, having type string[]\r\n  ArgumentParams = 'argumentParams',\r\n\r\n  // DPI_ActionType, having type ActionType\r\n  ActionType = 'actionType',\r\n\r\n  // DPI_AnnotateEnum, having type AnnotateEnum\r\n  AnnotateEnum = 'annotateEnum',\r\n\r\n  // DPI_JoinType, having type SQLJoinType\r\n  JoinType = 'joinType',\r\n\r\n  // DPI_SupportedJoinTypes, having type SQLJoinType[]\r\n  SupportedJoinTypes = 'supportedJoinTypes',\r\n\r\n  // DPI_Rounding, having type Rounding\r\n  Rounding = 'roundingEnum',\r\n\r\n  // DPI_BodyType, having type BodyType\r\n  BodyType = 'bodyType',\r\n\r\n  // DPI_LineEnd, having type LineEnd\r\n  LineEnd = 'lineEndEnum',\r\n\r\n  // DPI_LineEndSize, having type LineEndSize\r\n  LineEndSize = 'lineEndSizeEnum',\r\n\r\n  // DPI_BrushSpecialFields, having type BrushSpecialFields\r\n  BrushSpecialFields = 'specialFields',\r\n\r\n  // DPI_CellSizeChange, having type CellSizeChange\r\n  CellSizeChange = 'cellSizeChange',\r\n\r\n  // DPI_CellType, having type CellType\r\n  CellType = 'cellType',\r\n\r\n  // DPI_ConnectionAttemptResult, having type ConnectionAttemptResult\r\n  ConnectionAttemptResult = 'connectionAttemptResult',\r\n\r\n  // DPI_ConnectionErrorStage, having type ConnectionErrorStage\r\n  ConnectionErrorStage = 'connectionErrorStage',\r\n\r\n  // DPI_ConnectionErrorType, having type ConnectionErrorType\r\n  ConnectionErrorType = 'connectionErrorType',\r\n\r\n  // DPI_DataServerConnectionResult, having type DataServerConnectionResult\r\n  DataServerConnectionResult = 'dsConnectionResult',\r\n\r\n  // DPI_DropWhen, having type DropWhen\r\n  DropWhen = 'dropWhen',\r\n\r\n  // DPI_DropType, having type DropFieldResult\r\n  DropType = 'dropType',\r\n\r\n  // DPI_EncodingType, having type EncodingType\r\n  EncodingType = 'encodingType',\r\n\r\n  // DPI_DropdownEncodingType, having type EncodingType\r\n  DropdownEncodingType = 'dropdownEncodingType',\r\n\r\n  // DPI_EncodingTypes, having type EncodingType[]\r\n  EncodingTypes = 'encodingTypes',\r\n\r\n  // DPI_FieldOrderType, having type FieldOrderType\r\n  FieldOrderType = 'fieldOrderType',\r\n\r\n  // DPI_FilterIconType, having type FilterIconType\r\n  FilterIconType = 'filterIconType',\r\n\r\n  // DPI_FilterIconTypes, having type FilterIconType[]\r\n  FilterIconTypes = 'filterIconTypes',\r\n\r\n  // DPI_FloatingToolbarVis, having type FloatingToolbarVisibility\r\n  FloatingToolbarVis = 'toolbarVisibility',\r\n\r\n  // DPI_FolderRole, having type FolderRole\r\n  FolderRole = 'folderRole',\r\n\r\n  // DPI_LegendType, having type Enum\r\n  LegendType = 'legendType',\r\n\r\n  // DPI_ForecastModelType, having type ForecastModelType\r\n  ForecastModelType = 'forecastModelType',\r\n\r\n  // DPI_ForecastTrendType, having type ForecastComponentType\r\n  ForecastTrendType = 'forecastTrendType',\r\n\r\n  // DPI_ForecastSeasonType, having type ForecastComponentType\r\n  ForecastSeasonType = 'forecastSeasonType',\r\n\r\n  // DPI_ForecastRangeType, having type ForecastRangeType\r\n  ForecastRangeType = 'forecastRangeType',\r\n\r\n  // DPI_ForecastStatus, having type ForecastStatus\r\n  ForecastStatus = 'forecastStatus',\r\n\r\n  // DPI_SheetForecastStatus, having type ForecastStatus\r\n  SheetForecastStatus = 'sheetForecastStatus',\r\n\r\n  // DPI_PDForecastStatusList, having type ForecastStatus[]\r\n  PDForecastStatusList = 'paneDescriptorForecastStatusList',\r\n\r\n  // DPI_ForecastColumnType, having type ForecastColumnType\r\n  ForecastColumnType = 'forecastColumnType',\r\n\r\n  // DPI_DataScaling, having type DataScaling\r\n  DataScaling = 'dataScaling',\r\n\r\n  // DPI_GetFilterItemsJsonResponse, having type GetJsonResponseEnum\r\n  GetFilterItemsJsonResponse = 'getFilterItemsJsonResponse',\r\n\r\n  // DPI_FilterSearchJsonResponse, having type GetJsonResponseEnum\r\n  FilterSearchJsonResponse = 'filterSearchJsonResponse',\r\n\r\n  // DPI_FilterSearchWithIndexJsonResponse, having type GetJsonResponseEnum\r\n  FilterSearchWithIndexJsonResponse = 'filterSearchWithIndexJsonResponse',\r\n\r\n  // DPI_FilterShowChildrenJsonResponse, having type GetJsonResponseEnum\r\n  FilterShowChildrenJsonResponse = 'filterShowChildrenJsonResponse',\r\n\r\n  // DPI_HAlignment, having type LabelHAlignment\r\n  HAlignment = 'horizontalLabelAlignment',\r\n\r\n  // DPI_JoinValidationError, having type JoinValidationError\r\n  JoinValidationError = 'joinValidationError',\r\n\r\n  // DPI_NameConflictResolution, having type NameConflictResolution\r\n  NameConflictResolution = 'nameConflictResolution',\r\n\r\n  // DPI_LabelDir, having type TextOrient\r\n  LabelDir = 'labelDirection',\r\n\r\n  // DPI_LabelAlign, having type TextAlign\r\n  LabelAlign = 'labelAlignment',\r\n\r\n  // DPI_LabelWrap, having type TextWrapMode\r\n  LabelWrap = 'labelWrap',\r\n\r\n  // DPI_WrapMode, having type TextWrapMode\r\n  WrapMode = 'wrapMode',\r\n\r\n  // DPI_MarkEnum, having type MarkEnum\r\n  MarkEnum = 'markEnum',\r\n\r\n  // DPI_PercentMode, having type PercentMode\r\n  PercentMode = 'percentageMode',\r\n\r\n  // DPI_ReferenceOptionsSet, having type ReferenceOptionsSet\r\n  ReferenceOptionsSet = 'referenceOptionsSet',\r\n\r\n  // DPI_ReferenceOptionsSets, having type ReferenceOptionsSet[]\r\n  ReferenceOptionsSets = 'referenceOptionsSets',\r\n\r\n  // DPI_RankType, having type RankType\r\n  RankType = 'rankType',\r\n\r\n  // DPI_RankTypeValues, having type RankType[]\r\n  RankTypeValues = 'rankTypeValues',\r\n\r\n  // DPI_SpecialValuesMode, having type SpecialValuesMode\r\n  SpecialValuesMode = 'specialValuesMode',\r\n\r\n  // DPI_VAlignment, having type LabelVAlignment\r\n  VAlignment = 'verticalLabelAlignment',\r\n\r\n  // DPI_ColorMode, having type ColorMode\r\n  ColorMode = 'colorMode',\r\n\r\n  // DPI_MarkLabelsMode, having type MarkLabelsMode\r\n  MarkLabelsMode = 'markLabelsMode',\r\n\r\n  // DPI_MarkLabelsScope, having type MarkLabelsScope\r\n  MarkLabelsScope = 'markLabelsScope',\r\n\r\n  // DPI_MarkLabelsVisibility, having type MarkLabelsVisibility\r\n  MarkLabelsVisibility = 'markLabelsVisibility',\r\n\r\n  // DPI_PrimitiveType, having type PrimitiveType\r\n  PrimitiveType = 'primitiveType',\r\n\r\n  // DPI_ActualPrimitiveType, having type PrimitiveType\r\n  ActualPrimitiveType = 'actualPrimitiveType',\r\n\r\n  // DPI_PrimitiveTypes, having type PrimitiveType[]\r\n  PrimitiveTypes = 'primitiveTypes',\r\n\r\n  // DPI_ShapeType, having type ShapeType\r\n  ShapeType = 'shapeType',\r\n\r\n  // DPI_SortType, having type SortType\r\n  SortType = 'sortBy',\r\n\r\n  // DPI_SortEnd, having type SortEnd\r\n  SortEnd = 'sortEnd',\r\n\r\n  // DPI_StackingMode, having type StackingMode\r\n  StackingMode = 'stackingMode',\r\n\r\n  // DPI_StyleTheme, having type StyleTheme\r\n  StyleTheme = 'styleTheme',\r\n\r\n  // DPI_TrendLineFitType, having type TrendLineFitType\r\n  TrendLineFitType = 'fitType',\r\n\r\n  // DPI_UpdateScope, having type UpdateScope\r\n  UpdateScope = 'updateScope',\r\n\r\n  // DPI_ParameterCtrlDisplayMode, having type DisplayMode\r\n  ParameterCtrlDisplayMode = 'paramDisplayMode',\r\n\r\n  // DPI_ParameterCtrlDisplayFlag, having type ParameterCtrlDisplayFlag\r\n  ParameterCtrlDisplayFlag = 'paramDisplayFlag',\r\n\r\n  // DPI_Included, having type QuantitativeIncludedValues\r\n  Included = 'included',\r\n\r\n  // DPI_CommandsType, having type CommandsType\r\n  CommandsType = 'commandsType',\r\n\r\n  // DPI_ParameterDomainType, having type DomainType\r\n  ParameterDomainType = 'parameterDomainType',\r\n\r\n  // DPI_FilterDomainType, having type DomainType\r\n  FilterDomainType = 'filterDomainType',\r\n\r\n  // DPI_FilterDomains, having type DomainType[]\r\n  FilterDomains = 'filterDomains',\r\n\r\n  // DPI_CategoricalFilterType, having type CategoricalFilterType\r\n  CategoricalFilterType = 'categoricalFilterType',\r\n\r\n  // DPI_FilterPatternType, having type PatternType\r\n  FilterPatternType = 'filterPatternType',\r\n\r\n  // DPI_FilterConditionType, having type ConditionType\r\n  FilterConditionType = 'filterConditionType',\r\n\r\n  // DPI_FiltersPresetType, having type PresetType\r\n  FiltersPresetType = 'filtersPresetType',\r\n\r\n  // DPI_FiltersRangeType, having type RangeType\r\n  FiltersRangeType = 'filtersRangeType',\r\n\r\n  // DPI_DateRangeType, having type RelativeDateRangeType\r\n  DateRangeType = 'dateRangeType',\r\n\r\n  // DPI_PageFlag, having type PageNavFlags\r\n  PageFlag = 'pageFlag',\r\n\r\n  // DPI_MarksToTrail, having type MarksToTrail\r\n  MarksToTrail = 'marksToTrail',\r\n\r\n  // DPI_TrailType, having type TrailType\r\n  TrailType = 'trailType',\r\n\r\n  // DPI_ChangePageDirection, having type ChangePageType\r\n  ChangePageDirection = 'changeTo',\r\n\r\n  // DPI_AnimationControl, having type PageAnimationControl\r\n  AnimationControl = 'animationControl',\r\n\r\n  // DPI_LinePattern, having type LinePattern\r\n  LinePattern = 'linePattern',\r\n\r\n  // DPI_LineCap, having type LineCap\r\n  LineCap = 'lineCap',\r\n\r\n  // DPI_LineJoin, having type LineJoin\r\n  LineJoin = 'lineJoin',\r\n\r\n  // DPI_LineAlignment, having type LineAlignment\r\n  LineAlignment = 'lineAlignment',\r\n\r\n  // DPI_FillMode, having type FillMode\r\n  FillMode = 'fillMode',\r\n\r\n  // DPI_CursorShape, having type CursorShape\r\n  CursorShape = 'cursorShape',\r\n\r\n  // DPI_ShowMeCommandType, having type ShowMeCommandType\r\n  ShowMeCommandType = 'showMeCommandType',\r\n\r\n  // DPI_ShelfIconType, having type ShelfIconType\r\n  ShelfIconType = 'shelfIconType',\r\n\r\n  // DPI_ShelfIconTypes, having type ShelfIconType[]\r\n  ShelfIconTypes = 'shelfIconTypes',\r\n\r\n  // DPI_ItemDrawStyle, having type ItemDrawStyle\r\n  ItemDrawStyle = 'itemDrawStyle',\r\n\r\n  // DPI_ScaleMode, having type ScaleMode\r\n  ScaleMode = 'pageScaleMode',\r\n\r\n  // DPI_PageOrientationOption, having type PageOrientation\r\n  PageOrientationOption = 'pageOrientationOption',\r\n\r\n  // DPI_PageSizeOption, having type PageSizeOption\r\n  PageSizeOption = 'pageSizeOption',\r\n\r\n  // DPI_SortRegionType, having type SortRegionType\r\n  SortRegionType = 'sortRegion',\r\n\r\n  // DPI_LegendItemLayout, having type LegendItemLayout\r\n  LegendItemLayout = 'legendLayout',\r\n\r\n  // DPI_LegendItemOrder, having type LegendItemOrder\r\n  LegendItemOrder = 'legendOrder',\r\n\r\n  // DPI_VizImageRegion, having type VizImageRegion\r\n  VizImageRegion = 'r',\r\n\r\n  // DPI_LegacyMenuName, having type LegacyMenuName\r\n  LegacyMenuName = 'legacyMenuName',\r\n\r\n  // DPI_LegacyMenuState, having type LegacyMenuState\r\n  LegacyMenuState = 'legacyMenuState',\r\n\r\n  // DPI_LegacyMenuStateList, having type LegacyMenuState[]\r\n  LegacyMenuStateList = 'legacyMenuStates',\r\n\r\n  // DPI_DimensionType, having type DimensionType\r\n  DimensionType = 'dimensionType',\r\n\r\n  // DPI_LayoutType, having type LayoutType\r\n  LayoutType = 'layoutType',\r\n\r\n  // DPI_ShelfType, having type ShelfType\r\n  ShelfType = 'shelfType',\r\n\r\n  // DPI_LastSelectionShelf, having type ShelfType\r\n  LastSelectionShelf = 'lastShelf',\r\n\r\n  // DPI_SchemaViewerDataSourceType, having type SchemaViewerDataSourceType\r\n  SchemaViewerDataSourceType = 'schemaDatasourceType',\r\n\r\n  // DPI_SchemaItemType, having type SchemaItemType\r\n  SchemaItemType = 'schemaItemType',\r\n\r\n  // DPI_HSMSelectionMode, having type SelectionMode\r\n  HSMSelectionMode = 'hsmSelectionMode',\r\n\r\n  // DPI_HSMDefaultMemberType, having type DefaultMemberType\r\n  HSMDefaultMemberType = 'hsmDefaultMemberType',\r\n\r\n  // DPI_HSMNotificationType, having type NotificationType\r\n  HSMNotificationType = 'hsmNotificationType',\r\n\r\n  // DPI_HSMSelectionRequestType, having type SelectionRequestType\r\n  HSMSelectionRequestType = 'hsmSelectionRequestType',\r\n\r\n  // DPI_HSMMemberSelectRequestType, having type MemberSelectRequestType\r\n  HSMMemberSelectRequestType = 'hsmMemberSelectRequestType',\r\n\r\n  // DPI_PivotStrategy, having type FieldPivotStrategy\r\n  PivotStrategy = 'pivotStrategy',\r\n\r\n  // DPI_AliasType, having type AliasType\r\n  AliasType = 'aliasType',\r\n\r\n  // DPI_DSODimensionSortOrder, having type DataSourceOrder\r\n  DSODimensionSortOrder = 'dsoDimensionSortOrder',\r\n\r\n  // DPI_DSOMeasureSortOrder, having type DataSourceOrder\r\n  DSOMeasureSortOrder = 'dsoMeasureSortOrder',\r\n\r\n  // DPI_DSOSortOrder, having type DataSourceOrder\r\n  DSOSortOrder = 'dsoSortOrder',\r\n\r\n  // DPI_VTAggType, having type VTAggType\r\n  VTAggType = 'vtAggregation',\r\n\r\n  // DPI_FieldTypeIconSet, having type FieldTypeIconSet\r\n  FieldTypeIconSet = 'fieldIconSet',\r\n\r\n  // DPI_VisualPart, having type VisualPart\r\n  VisualPart = 'visualPart',\r\n\r\n  // DPI_DefaultMapToolEnum, having type MapToolSelection\r\n  DefaultMapToolEnum = 'defaultMapToolEnum',\r\n\r\n  // DPI_DefaultMapUnitEnum, having type MapUnitSelectionEnum\r\n  DefaultMapUnitEnum = 'defaultMapUnitEnum',\r\n\r\n  // DPI_SceneModelDetail, having type Detail\r\n  SceneModelDetail = 'sceneModelDetailEnum',\r\n\r\n  // DPI_SceneModelHitType, having type HitType\r\n  SceneModelHitType = 'sceneModelHitType',\r\n\r\n  // DPI_HitTestStyle, having type HitTestStyle\r\n  HitTestStyle = 'hitTestStyle',\r\n\r\n  // DPI_MarkState, having type MarkState\r\n  MarkState = 'markState',\r\n\r\n  // DPI_SheetType, having type SheetType\r\n  SheetType = 'sheetType',\r\n\r\n  // DPI_DragSource, having type DragDropType\r\n  DragSource = 'dragSource',\r\n\r\n  // DPI_DropTarget, having type DragDropType\r\n  DropTarget = 'dropTarget',\r\n\r\n  // DPI_ShelfDropAction, having type ShelfDropAction\r\n  ShelfDropAction = 'shelfDropAction',\r\n\r\n  // DPI_ShelfDropContext, having type ShelfDropContext\r\n  ShelfDropContext = 'shelfDropContext',\r\n\r\n  // DPI_FilterSelectionTracking, having type SelectionTracking\r\n  FilterSelectionTracking = 'filterSelectionTracking',\r\n\r\n  // DPI_FilterUpdateType, having type FilterUpdateType\r\n  FilterUpdateType = 'filterUpdateType',\r\n\r\n  // DPI_FilterUpdateQualifierType, having type FilterUpdateQualifierType\r\n  FilterUpdateQualifierType = 'filterUpdateQualifierType',\r\n\r\n  // DPI_ParameterError, having type ParameterError\r\n  ParameterError = 'parameterError',\r\n\r\n  // DPI_SelectionType, having type SelectionType\r\n  SelectionType = 'selectionType',\r\n\r\n  // DPI_SelectionUpdateType, having type SelectionUpdateType\r\n  SelectionUpdateType = 'selectionUpdateType',\r\n\r\n  // DPI_SelectOptions, having type SelectOptions\r\n  SelectOptions = 'selectOptions',\r\n\r\n  // DPI_WhitespaceSelectionBehavior, having type WhitespaceSelectionBehavior\r\n  WhitespaceSelectionBehavior = 'whitespaceSelectionBehavior',\r\n\r\n  // DPI_AxisOrientation, having type Orientation\r\n  AxisOrientation = 'axisOrientation',\r\n\r\n  // DPI_DecimalMode, having type DecimalMode\r\n  DecimalMode = 'decimalMode',\r\n\r\n  // DPI_ActivationMethod, having type ActivationMethod\r\n  ActivationMethod = 'activation',\r\n\r\n  // DPI_SourceType, having type SourceType\r\n  SourceType = 'sourceType',\r\n\r\n  // DPI_OnClear, having type OnClear\r\n  OnClear = 'onClear',\r\n\r\n  // DPI_MergeOrSplit, having type MergeOrSplit\r\n  MergeOrSplit = 'mergeOrSplit',\r\n\r\n  // DPI_FilterMode, having type FilterMode\r\n  FilterMode = 'filterMode',\r\n\r\n  // DPI_FilterType, having type FilterType\r\n  FilterType = 'filterType',\r\n\r\n  // DPI_ZoneType, having type ZoneType\r\n  ZoneType = 'zoneType',\r\n\r\n  // DPI_ZoneLayoutType, having type ZoneLayoutType\r\n  ZoneLayoutType = 'zoneLayoutType',\r\n\r\n  // DPI_QuickTableCalcType, having type QuickTableCalcCommandType\r\n  QuickTableCalcType = 'quickTableCalcType',\r\n\r\n  // DPI_TableCalcCommandType, having type TableCalcCommandType\r\n  TableCalcCommandType = 'tableCalcCommandType',\r\n\r\n  // DPI_TableCalcAddressType, having type TableCalcAddressCommandType\r\n  TableCalcAddressType = 'tableCalcAddressType',\r\n\r\n  // DPI_MarkLayoutPrimitive, having type Primitive\r\n  MarkLayoutPrimitive = 'markLayoutPrimitive',\r\n\r\n  // DPI_MarkLayoutVizType, having type VizType\r\n  MarkLayoutVizType = 'markLayoutVizType',\r\n\r\n  // DPI_MarkAlignment, having type MarkAlignment\r\n  MarkAlignment = 'markAlignment',\r\n\r\n  // DPI_ModifyZoneZOrderType, having type ModifyZoneZOrderCommandType\r\n  ModifyZoneZOrderType = 'modifyZoneZOrderType',\r\n\r\n  // DPI_TextRegionHAlign, having type TextRegionHAlign\r\n  TextRegionHAlign = 'halign',\r\n\r\n  // DPI_TextRegionVAlign, having type TextRegionVAlign\r\n  TextRegionVAlign = 'valign',\r\n\r\n  // DPI_PathElement, having type PathElement\r\n  PathElement = 'pathElement',\r\n\r\n  // DPI_PathElements, having type PathElement[]\r\n  PathElements = 'pathElements',\r\n\r\n  // DPI_RenderMode, having type RenderMode\r\n  RenderMode = 'renderMode',\r\n\r\n  // DPI_FontStyle, having type TableauFontStyle\r\n  FontStyle = 'fontStyle',\r\n\r\n  // DPI_FontWeight, having type FontWeight\r\n  FontWeight = 'fontWeight',\r\n\r\n  // DPI_TextDecoration, having type TextDecoration\r\n  TextDecoration = 'textDecoration',\r\n\r\n  // DPI_BorderStyle, having type BorderStyle\r\n  BorderStyle = 'borderStyle',\r\n\r\n  // DPI_BorderStyleTop, having type BorderStyle\r\n  BorderStyleTop = 'borderStyleTop',\r\n\r\n  // DPI_BorderStyleRight, having type BorderStyle\r\n  BorderStyleRight = 'borderStyleRight',\r\n\r\n  // DPI_BorderStyleBottom, having type BorderStyle\r\n  BorderStyleBottom = 'borderStyleBottom',\r\n\r\n  // DPI_BorderStyleLeft, having type BorderStyle\r\n  BorderStyleLeft = 'borderStyleLeft',\r\n\r\n  // DPI_FloatingToolbarVisibility, having type FloatingToolbarVisibility\r\n  FloatingToolbarVisibility = 'floatingToolbarVisibility',\r\n\r\n  // DPI_GeoSearchVisibility, having type GeoSearchVisibility\r\n  GeoSearchVisibility = 'geographicSearchVisibility',\r\n\r\n  // DPI_MapScaleVisibility, having type MapScaleVisibility\r\n  MapScaleVisibility = 'mapScaleVisibility',\r\n\r\n  // DPI_VizNavigationSetting, having type VizNavigationSetting\r\n  VizNavigationSetting = 'vizNavigationSetting',\r\n\r\n  // DPI_AutoDrillVisibility, having type AutoDrillVisibility\r\n  AutoDrillVisibility = 'autoDrillVisibility',\r\n\r\n  // DPI_ClientUIMetricType, having type ClientUIMetricType\r\n  ClientUIMetricType = 'clientUiMetricType',\r\n\r\n  // DPI_SheetScrollDirection, having type SheetScrollDirection\r\n  SheetScrollDirection = 'sheetScrollDirection',\r\n\r\n  // DPI_SizeMode, having type SizeMode\r\n  SizeMode = 'sizeMode',\r\n\r\n  // DPI_PerspectiveAggregate, having type PerspectiveAggregate\r\n  PerspectiveAggregate = 'perspectiveAggregation',\r\n\r\n  // DPI_StyleAttribute, having type StyleAttribute\r\n  StyleAttribute = 'styleAttribute',\r\n\r\n  // DPI_StyleAttributes, having type StyleAttribute[]\r\n  StyleAttributes = 'styleAttributes',\r\n\r\n  // DPI_StyleElement, having type StyleElement\r\n  StyleElement = 'styleElement',\r\n\r\n  // DPI_StyleDataClass, having type StyleDataClass\r\n  StyleDataClass = 'styleClass',\r\n\r\n  // DPI_StyleFieldScope, having type StyleFieldScope\r\n  StyleFieldScope = 'styleScope',\r\n\r\n  // DPI_FormatControlType, having type FormatControlType\r\n  FormatControlType = 'formatType',\r\n\r\n  // DPI_LineInterpolationMode, having type LineInterpolationMode\r\n  LineInterpolationMode = 'lineInterpolationMode',\r\n\r\n  // DPI_LineMarkerPosition, having type LineMarkerPosition\r\n  LineMarkerPosition = 'lineMarkerPosition',\r\n\r\n  // DPI_MarkersMode, having type MarkMarkersMode\r\n  MarkersMode = 'markersMode',\r\n\r\n  // DPI_AppConfigEnum, having type AppConfigEnum\r\n  AppConfigEnum = 'appConfigEnum',\r\n\r\n  // DPI_ColorPaletteType, having type ColorPaletteType\r\n  ColorPaletteType = 'colorPaletteType',\r\n\r\n  // DPI_ExtractType, having type ExtractType\r\n  ExtractType = 'extractType',\r\n\r\n  // DPI_ActivityDisposition, having type ActivityDisposition\r\n  ActivityDisposition = 'activityDisposition',\r\n\r\n  // DPI_ActivityResult, having type ActivityResult\r\n  ActivityResult = 'activityResult',\r\n\r\n  // DPI_TooltipMode, having type TooltipMode\r\n  TooltipMode = 'tooltipMode',\r\n\r\n  // DPI_RuntimeOutput, having type RuntimeOutput\r\n  RuntimeOutput = 'runtimeOutput',\r\n\r\n  // DPI_AnalyticsObjectType, having type AnalyticsObjectType\r\n  AnalyticsObjectType = 'analyticsObjectType',\r\n\r\n  // DPI_UIAutomationStatus, having type UIAutomationCommandStatus\r\n  UIAutomationStatus = 'uiAutomationStatus',\r\n\r\n  // DPI_TableViewDataType, having type TableViewDataType\r\n  TableViewDataType = 'tableViewerDataType',\r\n\r\n  // DPI_UnitsFormat, having type UnitsFormatEnum\r\n  UnitsFormat = 'unitsFormat',\r\n\r\n  // DPI_FilterLimitType, having type LimitType\r\n  FilterLimitType = 'filterLimitType',\r\n\r\n  // DPI_DistributionSelectedType, having type DistributionType\r\n  DistributionSelectedType = 'distributionSelectedType',\r\n\r\n  // DPI_DistributionType, having type DistributionType\r\n  DistributionType = 'distributionType',\r\n\r\n  // DPI_TranslatedDistributionType, having type TranslatedDistributionTypePresModel\r\n  TranslatedDistributionType = 'translatedDistributionType',\r\n\r\n  // DPI_TranslatedDistributionTypes, having type TranslatedDistributionTypePresModel[]\r\n  TranslatedDistributionTypes = 'translatedDistributionTypes',\r\n\r\n  // DPI_RefLineFormulaGroup, having type FormulaGroup\r\n  RefLineFormulaGroup = 'reflineFormulaGroup',\r\n\r\n  // DPI_ReferenceLineScopeType, having type ScopeType\r\n  ReferenceLineScopeType = 'referenceLineScopeType',\r\n\r\n  // DPI_StDevType, having type StDevType\r\n  StDevType = 'stdevType',\r\n\r\n  // DPI_ShowBounds, having type ShowBounds\r\n  ShowBounds = 'showBounds',\r\n\r\n  // DPI_BoxplotWhiskerType, having type BoxplotWhiskerType\r\n  BoxplotWhiskerType = 'boxplotWhiskerType',\r\n\r\n  // DPI_ReferenceLineLabelType, having type LabelType\r\n  ReferenceLineLabelType = 'referenceLineLabelType',\r\n\r\n  // DPI_PairedReferenceLineLabelType, having type LabelType\r\n  PairedReferenceLineLabelType = 'pairedReferenceLineLabelType',\r\n\r\n  // DPI_ConfidenceIntervalSelectedState, having type ConfidenceIntervalState\r\n  ConfidenceIntervalSelectedState = 'confidenceIntervalSelectedState',\r\n\r\n  // DPI_ConfidenceIntervalState, having type ConfidenceIntervalState\r\n  ConfidenceIntervalState = 'confidenceIntervalState',\r\n\r\n  // DPI_TranslatedLabelType, having type TranslatedLabelTypePresModel\r\n  TranslatedLabelType = 'translatedLabelType',\r\n\r\n  // DPI_ReferenceLineValidLabelTypes, having type TranslatedLabelTypePresModel[]\r\n  ReferenceLineValidLabelTypes = 'validReferenceLineLabelTypes',\r\n\r\n  // DPI_ReferenceLineFormulaType, having type FormulaType\r\n  ReferenceLineFormulaType = 'referenceLineFormulaType',\r\n\r\n  // DPI_PairedReferenceLineFormulaType, having type FormulaType\r\n  PairedReferenceLineFormulaType = 'pairedReferenceLineFormulaType',\r\n\r\n  // DPI_TranslatedFormulaType, having type TranslatedFormulaTypePresModel\r\n  TranslatedFormulaType = 'translatedFormulaType',\r\n\r\n  // DPI_ReferenceLineValidFormulaTypes, having type TranslatedFormulaTypePresModel[]\r\n  ReferenceLineValidFormulaTypes = 'validReferenceLineFormulaTypes',\r\n\r\n  // DPI_ReferenceLineValidPairedFormulaTypes, having type TranslatedFormulaTypePresModel[]\r\n  ReferenceLineValidPairedFormulaTypes = 'validReferenceLinePairedFormulaTypes',\r\n\r\n  // DPI_TranslatedConfidenceIntervalState, having type TranslatedConfidenceIntervalStatePresModel\r\n  TranslatedConfidenceIntervalState = 'translatedConfidenceIntervalState',\r\n\r\n  // DPI_TranslatedConfidenceIntervalStates, having type TranslatedConfidenceIntervalStatePresModel[]\r\n  TranslatedConfidenceIntervalStates = 'translatedConfidenceIntervalStates',\r\n\r\n  // DPI_TranslatedStDevType, having type TranslatedStDevTypePresModel\r\n  TranslatedStDevType = 'translatedStdevType',\r\n\r\n  // DPI_TranslatedStDevTypes, having type TranslatedStDevTypePresModel[]\r\n  TranslatedStDevTypes = 'translatedStdevTypes',\r\n\r\n  // DPI_ReferenceLineLODCalcType, having type LODCalcType\r\n  ReferenceLineLODCalcType = 'referenceLineLodCalcType',\r\n\r\n  // DPI_ValueDomainType, having type ValueDomainType\r\n  ValueDomainType = 'valueDomainType',\r\n\r\n  // DPI_ValueDomainTypes, having type ValueDomainType[]\r\n  ValueDomainTypes = 'valueDomainTypes',\r\n\r\n  // DPI_OperationType, having type OperationType\r\n  OperationType = 'operationType',\r\n\r\n  // DPI_OperationTypes, having type OperationType[]\r\n  OperationTypes = 'operationTypes',\r\n\r\n  // DPI_ConnectionTypeCategory, having type ConnectionTypeCategory\r\n  ConnectionTypeCategory = 'connectionTypeCategory',\r\n\r\n  // DPI_ConnectionTypeGroup, having type ConnectionTypeGroup\r\n  ConnectionTypeGroup = 'connectionTypeGroup',\r\n\r\n  // DPI_CommandRedirectType, having type CommandRedirectType\r\n  CommandRedirectType = 'commandRedirectType',\r\n\r\n  // DPI_CustomSplitMode, having type SplitMode\r\n  CustomSplitMode = 'customSplitMode',\r\n\r\n  // DPI_CustomSplitSeparatorType, having type SeparatorType\r\n  CustomSplitSeparatorType = 'customSplitSeparatorType',\r\n\r\n  // DPI_LevelSelectionState, having type LevelSelectionState\r\n  LevelSelectionState = 'levelSelectionState',\r\n\r\n  // DPI_LevelSelectionStates, having type LevelSelectionState[]\r\n  LevelSelectionStates = 'levelSelectionStates',\r\n\r\n  // DPI_SourceDestIcon, having type SourceDestIcon\r\n  SourceDestIcon = 'sourceDestIcon',\r\n\r\n  // DPI_LegendLayout, having type LegendLayout\r\n  LegendLayout = 'pageLegendLayout',\r\n\r\n  // DPI_ImagesEditResultCode, having type ImagesEditResultCode\r\n  ImagesEditResultCode = 'imagesEditResultCode',\r\n\r\n  // DPI_CalculationContext, having type CalculationContext\r\n  CalculationContext = 'calculationContext',\r\n\r\n  // DPI_WorkgroupPublishErrorType, having type WorkgroupPublishErrorType\r\n  WorkgroupPublishErrorType = 'workgroupPublishErrorType',\r\n\r\n  // DPI_IsParameter, having type TriBool\r\n  IsParameter = 'isParameter',\r\n\r\n  // DPI_AddressingState, having type WidgetState\r\n  AddressingState = 'addressingState',\r\n\r\n  // DPI_AllPagesState, having type WidgetState\r\n  AllPagesState = 'allPagesState',\r\n\r\n  // DPI_AtTheLevelState, having type WidgetState\r\n  AtTheLevelState = 'atTheLevelState',\r\n\r\n  // DPI_ComputeCompoundedRateState, having type WidgetState\r\n  ComputeCompoundedRateState = 'computeCompoundedRateState',\r\n\r\n  // DPI_CustomNullIfIncompleteState, having type WidgetState\r\n  CustomNullIfIncompleteState = 'customNullIfIncompleteState',\r\n\r\n  // DPI_NestedCalcsState, having type WidgetState\r\n  NestedCalcsState = 'nestedCalcsState',\r\n\r\n  // DPI_RankTypeState, having type WidgetState\r\n  RankTypeState = 'rankTypeState',\r\n\r\n  // DPI_ReferenceOptionsState, having type WidgetState\r\n  ReferenceOptionsState = 'referenceOptionsState',\r\n\r\n  // DPI_RestartEveryState, having type WidgetState\r\n  RestartEveryState = 'restartEveryState',\r\n\r\n  // DPI_SortAggState, having type WidgetState\r\n  SortAggState = 'sortAggState',\r\n\r\n  // DPI_SortState, having type WidgetState\r\n  SortState = 'sortState',\r\n\r\n  // DPI_TableCalcTypeState, having type WidgetState\r\n  TableCalcTypeState = 'tableCalcTypeState',\r\n\r\n  // DPI_TableCalcAssistanceWidgetState, having type WidgetState\r\n  TableCalcAssistanceWidgetState = 'tableCalcAssistanceWidgetState',\r\n\r\n  // DPI_CalcNestingLevel, having type CalcNestingLevel\r\n  CalcNestingLevel = 'calcNestingLevel',\r\n\r\n  // DPI_DataProviderType, having type DataProviderType\r\n  DataProviderType = 'dataProviderType',\r\n\r\n  // DPI_HeuristicCommandReinterpretation, having type HeuristicCommandReinterpretation\r\n  HeuristicCommandReinterpretation = 'heuristicCommandReinterpretation',\r\n\r\n  // DPI_ExtractRefreshStatus, having type ExtractRefreshStatus\r\n  ExtractRefreshStatus = 'extractRefreshStatus',\r\n\r\n  // DPI_RichTextEditorWidgetKey, having type RichTextEditorWidgetKey\r\n  RichTextEditorWidgetKey = 'richTextEditorWidgetKey',\r\n\r\n  // DPI_RichTextWidgetKeys, having type RichTextEditorWidgetKey[]\r\n  RichTextWidgetKeys = 'richTextWidgetKeys',\r\n\r\n  // DPI_TypeOfFormatItem, having type TypeOfFormatItem\r\n  TypeOfFormatItem = 'typeOfFormatItem',\r\n\r\n  // DPI_TypeOfFormatContainer, having type TypeOfFormatContainer\r\n  TypeOfFormatContainer = 'typeOfFormatContainer',\r\n\r\n  // DPI_TypeOfFormatControl, having type TypeOfFormatControl\r\n  TypeOfFormatControl = 'typeOfFormatControl',\r\n\r\n  // DPI_FormatWidgetKey, having type FormatWidgetKey\r\n  FormatWidgetKey = 'formatWidgetKey',\r\n\r\n  // DPI_ColorSwatchType, having type ColorSwatchType\r\n  ColorSwatchType = 'formatColorSwatchType',\r\n\r\n  // DPI_PickerType, having type PickerType\r\n  PickerType = 'pickerType',\r\n\r\n  // DPI_ExtractHistoryRefreshType, having type RefreshType\r\n  ExtractHistoryRefreshType = 'extractHistoryRefreshTypeEnum',\r\n\r\n  // DPI_AxisFoldState, having type AxisFoldState\r\n  AxisFoldState = 'axisFoldState',\r\n\r\n  // DPI_TickMarkSpacingUnits, having type TickSpacingUnits\r\n  TickMarkSpacingUnits = 'tickSpacingUnits',\r\n\r\n  // DPI_TickMarkState, having type TickMarkState\r\n  TickMarkState = 'tickMarkState',\r\n\r\n  // DPI_AxisRangeType, having type AxisRangeType\r\n  AxisRangeType = 'axisRangeType',\r\n\r\n  // DPI_ScaleType, having type ScaleType\r\n  ScaleType = 'scaleType',\r\n\r\n  // DPI_DashboardDeviceLayout, having type DashboardDeviceLayout\r\n  DashboardDeviceLayout = 'dashboardDeviceLayout',\r\n\r\n  // DPI_ActivateDeviceLayout, having type DashboardDeviceLayout\r\n  ActivateDeviceLayout = 'activateDeviceLayout',\r\n\r\n  // DPI_DashboardDeviceLayouts, having type DashboardDeviceLayout[]\r\n  DashboardDeviceLayouts = 'dashboardDeviceLayouts',\r\n\r\n  // DPI_DeviceSource, having type DeviceSource\r\n  DeviceSource = 'deviceSource',\r\n\r\n  // DPI_DashboardSizingDimension, having type DashboardSizingDimension\r\n  DashboardSizingDimension = 'dashboardSizingDimension',\r\n\r\n  // DPI_GridOverlayMode, having type GridOverlayMode\r\n  GridOverlayMode = 'gridOverlayMode',\r\n\r\n  // DPI_DashboardSizingMode, having type DashboardSizingMode\r\n  DashboardSizingMode = 'dashboardSizingMode',\r\n\r\n  // DPI_FlipboardNavType, having type FlipboardNavType\r\n  FlipboardNavType = 'flipboardNavType',\r\n\r\n  // DPI_FieldPickerDialogUseCase, having type FieldPickerDialogUseCase\r\n  FieldPickerDialogUseCase = 'fieldPickerDialogUseCase',\r\n\r\n  // DPI_StartOfWeekEnum, having type SOWValue\r\n  StartOfWeekEnum = 'startOfWeekEnum',\r\n\r\n  // DPI_StartOfFiscalYear, having type FYSValues\r\n  StartOfFiscalYear = 'startOfFiscalYear',\r\n\r\n  // DPI_TotalsInclusionValue, having type TotalsInclusion\r\n  TotalsInclusionValue = 'totalsInclusionValue',\r\n\r\n  // DPI_FormatCode, having type FormatCode\r\n  FormatCode = 'formatCode',\r\n\r\n  // DPI_FindType, having type FindType\r\n  FindType = 'findType',\r\n\r\n  // DPI_PerspectiveType, having type PerspectiveType\r\n  PerspectiveType = 'perspectiveType',\r\n\r\n  // DPI_GeometryType, having type GeometryType\r\n  GeometryType = 'geometryType',\r\n\r\n  // DPI_PaneLabelComposition, having type PaneLabelComposition\r\n  PaneLabelComposition = 'paneLabelComposition',\r\n\r\n  // DPI_WarningType, having type WarningType\r\n  WarningType = 'warningType',\r\n\r\n  // DPI_UIMode, having type WorkbookUIMode\r\n  UIMode = 'uiMode',\r\n\r\n  // DPI_MenuItemId, having type TopLevelMenuItem\r\n  MenuItemId = 'menuItemId',\r\n\r\n  // DPI_CommandReturn, having type object\r\n  CommandReturn = 'commandReturn',\r\n\r\n  // DPI_LegacyPresModel, having type object\r\n  LegacyPresModel = 'legacyPresModel',\r\n\r\n  // DPI_PresentationModel, having type object\r\n  PresentationModel = 'presModelHolder',\r\n\r\n  // DPI_Event, having type object\r\n  Event = 'eventContainer',\r\n\r\n  // DPI_LineStyle, having type Array\r\n  LineStyle = 'lineStyle',\r\n\r\n  // DPI_StrokeStyle, having type Array\r\n  StrokeStyle = 'strokeStyle',\r\n\r\n  // DPI_Schema, having type Array\r\n  Schema = 'schema',\r\n\r\n  // DPI_StartTuple, having type Array\r\n  StartTuple = 'startTuple',\r\n\r\n  // DPI_EndTuple, having type Array\r\n  EndTuple = 'endTuple',\r\n\r\n  // DPI_Tuple, having type Array\r\n  Tuple = 'tuple',\r\n\r\n  // DPI_Tuples, having type Array[]\r\n  Tuples = 'tuples',\r\n\r\n  // DPI_CustomDomainTuples, having type Array[]\r\n  CustomDomainTuples = 'customDomainTuples',\r\n\r\n  // DPI_UpdatedTuples, having type Array[]\r\n  UpdatedTuples = 'updatedTuples',\r\n\r\n  // DPI_Table, having type Array\r\n  Table = 'table',\r\n\r\n  // DPI_AliasedValue, having type Array\r\n  AliasedValue = 'valueAlias',\r\n\r\n  // DPI_FirstAliasedValue, having type Array\r\n  FirstAliasedValue = 'firstAlisedValue',\r\n\r\n  // DPI_MaximumRange, having type Array\r\n  MaximumRange = 'maximumRangeValue',\r\n\r\n  // DPI_MinimumRange, having type Array\r\n  MinimumRange = 'minimumRangeValue',\r\n\r\n  // DPI_SecondAliasedValue, having type Array\r\n  SecondAliasedValue = 'secondAlisedValue',\r\n\r\n  // DPI_AliasedSelectionList, having type Array[]\r\n  AliasedSelectionList = 'aliasedSelectionList',\r\n\r\n  // DPI_AliasedValues, having type Array[]\r\n  AliasedValues = 'valuesAliases',\r\n\r\n  // DPI_VerboseAliasedRangeMax, having type Array\r\n  VerboseAliasedRangeMax = 'verboseAliasedRangeMax',\r\n\r\n  // DPI_VerboseAliasedValue, having type Array\r\n  VerboseAliasedValue = 'verboseAliasedValue',\r\n\r\n  // DPI_MultiBucket, having type MultiBucket\r\n  MultiBucket = 'xValues',\r\n\r\n  // DPI_PageName, having type PageName\r\n  PageName = 'pageName',\r\n\r\n  // DPI_Selector, having type object\r\n  Selector = 'selector',\r\n\r\n  // DPI_PaneId, having type object\r\n  PaneId = 'paneId',\r\n\r\n  // DPI_PaneIds, having type PaneId[]\r\n  PaneIds = 'paneIds',\r\n\r\n  // DPI_ImageRegionInfo, having type object\r\n  ImageRegionInfo = 'vizRegionRect',\r\n\r\n  // DPI_ImageRegionInfoList, having type object[]\r\n  ImageRegionInfoList = 'vizRegionRectList',\r\n\r\n  // DPI_VisualID, having type VisualID\r\n  VisualID = 'visualId',\r\n\r\n  // DPI_VisualIDPM, having type VisualIDPresModel\r\n  VisualIDPM = 'visualIdPresModel',\r\n\r\n  // DPI_InvalidSheets, having type VisualIDPresModel[]\r\n  InvalidSheets = 'invalidSheets',\r\n\r\n  // DPI_VisualIDPMs, having type VisualIDPresModel[]\r\n  VisualIDPMs = 'visualIds',\r\n\r\n  // DPI_SheetPathPM, having type SheetPathPresModel\r\n  SheetPathPM = 'sheetPath',\r\n\r\n  // DPI_CapturedSheetPM, having type SheetPathPresModel\r\n  CapturedSheetPM = 'capturedSheetPm',\r\n\r\n  // DPI_CurrentSheetPM, having type SheetPathPresModel\r\n  CurrentSheetPM = 'currentSheetPm',\r\n\r\n  // DPI_DashboardPM, having type SheetPathPresModel\r\n  DashboardPM = 'dashboardPm',\r\n\r\n  // DPI_NewSheetPM, having type SheetPathPresModel\r\n  NewSheetPM = 'newSheetPm',\r\n\r\n  // DPI_SheetNamePM, having type SheetPathPresModel\r\n  SheetNamePM = 'sheetNamePm',\r\n\r\n  // DPI_SheetPM, having type SheetPathPresModel\r\n  SheetPM = 'sheetPm',\r\n\r\n  // DPI_SourceDashboardPM, having type SheetPathPresModel\r\n  SourceDashboardPM = 'sourceDashboardPm',\r\n\r\n  // DPI_SourceSheetPM, having type SheetPathPresModel\r\n  SourceSheetPM = 'sourceSheetPm',\r\n\r\n  // DPI_TargetSheetPM, having type SheetPathPresModel\r\n  TargetSheetPM = 'targetSheetPm',\r\n\r\n  // DPI_WorksheetPM, having type SheetPathPresModel\r\n  WorksheetPM = 'worksheetPm',\r\n\r\n  // DPI_ModifiedSheets, having type SheetPathPresModel[]\r\n  ModifiedSheets = 'modifiedSheets',\r\n\r\n  // DPI_DataColumn, having type DataColumnPresModel\r\n  DataColumn = 'dataColumn',\r\n\r\n  // DPI_DataColumns, having type DataColumnPresModel[]\r\n  DataColumns = 'dataColumns',\r\n\r\n  // DPI_Addresses, having type DataColumnPresModel[]\r\n  Addresses = 'addresses',\r\n\r\n  // DPI_EncodingColumns, having type Dictionary(of DataColumnPresModel)\r\n  EncodingColumns = 'encodingColumns',\r\n\r\n  // DPI_TextRunColumns, having type Dictionary(of DataColumnPresModel)\r\n  TextRunColumns = 'textRunColumns',\r\n\r\n  // DPI_TextStyleColumns, having type Dictionary(of DataColumnPresModel)\r\n  TextStyleColumns = 'textStyleColumns',\r\n\r\n  // DPI_NamedDataColumn, having type NamedDataColumnPresModel\r\n  NamedDataColumn = 'namedDataColumn',\r\n\r\n  // DPI_NamedDataColumns, having type NamedDataColumnPresModel[]\r\n  NamedDataColumns = 'namedDataColumns',\r\n\r\n  // DPI_DataTable, having type DataTablePresModel\r\n  DataTable = 'dataTable',\r\n\r\n  // DPI_ActionSpecification, having type None\r\n  ActionSpecification = 'actionSpec',\r\n\r\n  // DPI_Column, having type Column\r\n  Column = 'columnContext',\r\n\r\n  // DPI_SetFunction, having type SetFunction\r\n  SetFunction = 'setFunction',\r\n\r\n  // DPI_SetFunctions, having type SetFunctions\r\n  SetFunctions = 'setFunctions',\r\n\r\n  // DPI_VisualProfileShowMe, having type VisualProfileShowMe\r\n  VisualProfileShowMe = 'vpsm',\r\n\r\n  // DPI_DataSourcePtr, having type DataSource\r\n  DataSourcePtr = 'datasourcePtr',\r\n\r\n  // DPI_WorkgroupConnection, having type WorkgroupConnection\r\n  WorkgroupConnection = 'workgroupConnection',\r\n\r\n  // DPI_Authenticator, having type AuthenticatorRawPtr\r\n  Authenticator = 'authenticator',\r\n\r\n  // DPI_UpgradeAttr, having type UpgradeAttr\r\n  UpgradeAttr = 'upgradeAttr',\r\n\r\n  // DPI_ExtractAttr, having type ExtractAttr\r\n  ExtractAttr = 'extractAttr',\r\n\r\n  // DPI_RefreshAttr, having type RefreshAttr\r\n  RefreshAttr = 'refreshAttr',\r\n\r\n  // DPI_ContextSpecification, having type ContextSpecification\r\n  ContextSpecification = 'contextSpecification',\r\n\r\n  // DPI_SchemaViewerSelector, having type SchemaViewerSelectorPtr\r\n  SchemaViewerSelector = 'schemaViewerSelector',\r\n\r\n  // DPI_Buckets, having type Buckets\r\n  Buckets = 'buckets',\r\n\r\n  // DPI_LegendItems, having type MultiBuckets\r\n  LegendItems = 'legendItems',\r\n\r\n  // DPI_LegendItem, having type MultiBucket\r\n  LegendItem = 'legendItem',\r\n\r\n  // DPI_SourceItem, having type MultiBucket\r\n  SourceItem = 'sourceItem',\r\n\r\n  // DPI_DestItem, having type MultiBucket\r\n  DestItem = 'destItem',\r\n\r\n  // DPI_IQuickSortState, having type IQuickSortState\r\n  IQuickSortState = 'quickSortState',\r\n\r\n  // DPI_AppBuildDate, having type DateTime\r\n  AppBuildDate = 'appBuildDate',\r\n\r\n  // DPI_ForecastDateRangeEnd, having type DateTime\r\n  ForecastDateRangeEnd = 'forecastDateRangeEnd',\r\n\r\n  // DPI_ForecastDateRangeStart, having type DateTime\r\n  ForecastDateRangeStart = 'forecastDateRangeStart',\r\n\r\n  // DPI_LastModified, having type DateTime\r\n  LastModified = 'lastModified',\r\n\r\n  // DPI_SearchDomainPtr, having type MultiDomain\r\n  SearchDomainPtr = 'searchDomainPtr',\r\n\r\n  // DPI_ResultsDomainPtr, having type MultiDomain\r\n  ResultsDomainPtr = 'resultsDomainPtr',\r\n\r\n  // DPI_Actions, having type object\r\n  Actions = 'actions',\r\n\r\n  // DPI_SRCommands, having type object\r\n  SRCommands = 'selectionRelaxationCommands',\r\n\r\n  // DPI_Commands, having type object\r\n  Commands = 'commands',\r\n\r\n  // DPI_DataTypeCommands, having type object\r\n  DataTypeCommands = 'datatypeCommands',\r\n\r\n  // DPI_MultiSelectCommands, having type object\r\n  MultiSelectCommands = 'multiselectCommands',\r\n\r\n  // DPI_NonVizCommands, having type object\r\n  NonVizCommands = 'nonVizCommands',\r\n\r\n  // DPI_QuickFilterCommands, having type object\r\n  QuickFilterCommands = 'quickFilterCommands',\r\n\r\n  // DPI_ShowMeCommands, having type object\r\n  ShowMeCommands = 'showMeCommands',\r\n\r\n  // DPI_SortIndicatorMenu, having type object\r\n  SortIndicatorMenu = 'sortIndicatorMenu',\r\n\r\n  // DPI_StandardCommands, having type object\r\n  StandardCommands = 'standardCommands',\r\n\r\n  // DPI_VizCommands, having type object\r\n  VizCommands = 'vizCommands',\r\n\r\n  // DPI_ZoneChromeCommands, having type object\r\n  ZoneChromeCommands = 'zoneChromeCommands',\r\n\r\n  // DPI_CommandItem, having type CommandsItem\r\n  CommandItem = 'commandItem',\r\n\r\n  // DPI_CommandItems, having type CommandsItem[]\r\n  CommandItems = 'commandItems',\r\n\r\n  // DPI_Command, having type SimpleCommandsPresModel\r\n  Command = 'simpleCommandModel',\r\n\r\n  // DPI_AddCommand, having type SimpleCommandsPresModel\r\n  AddCommand = 'addSimpleCommandModel',\r\n\r\n  // DPI_RemoveCommand, having type SimpleCommandsPresModel\r\n  RemoveCommand = 'removeSimpleCommandModel',\r\n\r\n  // DPI_AcceptCommand, having type SimpleCommandsPresModel\r\n  AcceptCommand = 'acceptSimpleCommandModel',\r\n\r\n  // DPI_DeclineCommand, having type SimpleCommandsPresModel\r\n  DeclineCommand = 'declineSimpleCommandModel',\r\n\r\n  // DPI_DropCommand, having type SimpleCommandsPresModel\r\n  DropCommand = 'dropCommandModel',\r\n\r\n  // DPI_EditCaptionCommand, having type SimpleCommandsPresModel\r\n  EditCaptionCommand = 'editCaptionCommandModel',\r\n\r\n  // DPI_FontCommand, having type SimpleCommandsPresModel\r\n  FontCommand = 'fontCommandModel',\r\n\r\n  // DPI_LineStyleCommand, having type SimpleCommandsPresModel\r\n  LineStyleCommand = 'lineStyleCommandModel',\r\n\r\n  // DPI_FormatCommand, having type SimpleCommandsPresModel\r\n  FormatCommand = 'formatCommandModel',\r\n\r\n  // DPI_DestructorCommand, having type SimpleCommandsPresModel\r\n  DestructorCommand = 'destructorCommand',\r\n\r\n  // DPI_ClearFormatCommand, having type SimpleCommandsPresModel\r\n  ClearFormatCommand = 'clearFormatCommandModel',\r\n\r\n  // DPI_RichTextCommand, having type SimpleCommandsPresModel\r\n  RichTextCommand = 'richTextCommandModel',\r\n\r\n  // DPI_SortIndicatorCommand, having type SimpleCommandsPresModel\r\n  SortIndicatorCommand = 'sortIndicatorCommand',\r\n\r\n  // DPI_ReleaseStoreCommand, having type SimpleCommandsPresModel\r\n  ReleaseStoreCommand = 'releaseStoreCommand',\r\n\r\n  // DPI_ConfirmationCommand, having type SimpleCommandsPresModel\r\n  ConfirmationCommand = 'confirmationCommand',\r\n\r\n  // DPI_CommandList, having type SimpleCommandsPresModel[]\r\n  CommandList = 'commandList',\r\n\r\n  // DPI_ParameterCtrl, having type ParameterCtrlPresModel\r\n  ParameterCtrl = 'parameterControl',\r\n\r\n  // DPI_ParameterCtrls, having type ParameterCtrlPresModel[]\r\n  ParameterCtrls = 'parameterControls',\r\n\r\n  // DPI_PageModel, having type PagePresModel\r\n  PageModel = 'pageModel',\r\n\r\n  // DPI_PageTrailOptions, having type PageTrailOptionsPresModel\r\n  PageTrailOptions = 'pageTrailOptions',\r\n\r\n  // DPI_Field, having type FieldPresModel\r\n  Field = 'field',\r\n\r\n  // DPI_FieldList, having type FieldPresModel[]\r\n  FieldList = 'fieldList',\r\n\r\n  // DPI_DimensionsFieldList, having type FieldPresModel[]\r\n  DimensionsFieldList = 'dimensionsFieldList',\r\n\r\n  // DPI_MeasuresFieldList, having type FieldPresModel[]\r\n  MeasuresFieldList = 'measuresFieldList',\r\n\r\n  // DPI_SetsFieldList, having type FieldPresModel[]\r\n  SetsFieldList = 'setsFieldList',\r\n\r\n  // DPI_ParametersFieldList, having type FieldPresModel[]\r\n  ParametersFieldList = 'parametersFieldList',\r\n\r\n  // DPI_FieldColumn, having type FieldColumnPresModel\r\n  FieldColumn = 'column',\r\n\r\n  // DPI_FieldColumnList, having type FieldColumnPresModel[]\r\n  FieldColumnList = 'columnList',\r\n\r\n  // DPI_StructuredMeasure, having type StructuredMeasurePresModel\r\n  StructuredMeasure = 'structuredMeasure',\r\n\r\n  // DPI_StructuredMeasureList, having type StructuredMeasurePresModel[]\r\n  StructuredMeasureList = 'structuredMeasureList',\r\n\r\n  // DPI_Level, having type LevelPresModel\r\n  Level = 'level',\r\n\r\n  // DPI_Parameter, having type ParameterPresModel\r\n  Parameter = 'parameter',\r\n\r\n  // DPI_BaseDimension, having type BaseDimensionPresModel\r\n  BaseDimension = 'baseDimension',\r\n\r\n  // DPI_Dimension, having type DimensionPresModel\r\n  Dimension = 'dimension',\r\n\r\n  // DPI_AttributeDimensionList, having type DimensionPresModel[]\r\n  AttributeDimensionList = 'attributeDimensionList',\r\n\r\n  // DPI_AttributeDimension, having type AttributeDimensionPresModel\r\n  AttributeDimension = 'attributeDimension',\r\n\r\n  // DPI_AttributeAttributeDimensionList, having type AttributeDimensionPresModel[]\r\n  AttributeAttributeDimensionList = 'attributeAttributeDimensionList',\r\n\r\n  // DPI_StandardDimension, having type StandardDimensionPresModel\r\n  StandardDimension = 'standardDimension',\r\n\r\n  // DPI_RelationalTable, having type RelationalTablePresModel\r\n  RelationalTable = 'relationalTable',\r\n\r\n  // DPI_DrillPath, having type DrillPathPresModel\r\n  DrillPath = 'drillPath',\r\n\r\n  // DPI_FieldFolder, having type FieldFolderPresModel\r\n  FieldFolder = 'fieldFolder',\r\n\r\n  // DPI_Group, having type GroupPresModel\r\n  Group = 'group',\r\n\r\n  // DPI_UserDefinedAttributeList, having type GroupPresModel[]\r\n  UserDefinedAttributeList = 'userDefinedAttributeList',\r\n\r\n  // DPI_Hierarchy, having type HierarchyPresModel\r\n  Hierarchy = 'hierarchy',\r\n\r\n  // DPI_HierarchyList, having type HierarchyPresModel[]\r\n  HierarchyList = 'hierarchyList',\r\n\r\n  // DPI_HierarchyMemberSelectedState, having type HierarchySelect_MemberSelectedStatePresModel\r\n  HierarchyMemberSelectedState = 'hierarchyMemberSelectedState',\r\n\r\n  // DPI_HierarchySelectionChanges, having type HierarchySelect_MemberSelectedStatePresModel[]\r\n  HierarchySelectionChanges = 'hierarchySelectionChanges',\r\n\r\n  // DPI_DisplayFolder, having type DisplayFolderPresModel\r\n  DisplayFolder = 'displayFolder',\r\n\r\n  // DPI_DisplayFolderList, having type DisplayFolderPresModel[]\r\n  DisplayFolderList = 'displayFolderList',\r\n\r\n  // DPI_DataSourceLayout, having type DataSourceLayoutPresModel\r\n  DataSourceLayout = 'dataSourceLayout',\r\n\r\n  // DPI_BaseDataSource, having type BaseDataSourcePresModel\r\n  BaseDataSource = 'baseDataSource',\r\n\r\n  // DPI_BaseDataSources, having type Dictionary(of BaseDataSourcePresModel)\r\n  BaseDataSources = 'baseDataSources',\r\n\r\n  // DPI_DataSource, having type DataSourcePresModel\r\n  DataSource = 'dataSource',\r\n\r\n  // DPI_DataSources, having type Dictionary(of DataSourcePresModel)\r\n  DataSources = 'dataSources',\r\n\r\n  // DPI_SchemaViewerDataSource, having type SchemaViewerDataSourcePresModel\r\n  SchemaViewerDataSource = 'schemaViewerDataSource',\r\n\r\n  // DPI_SchemaViewerDataSources, having type Dictionary(of SchemaViewerDataSourcePresModel)\r\n  SchemaViewerDataSources = 'schemaViewerDataSources',\r\n\r\n  // DPI_BaseDataSchema, having type BaseDataSchemaPresModel\r\n  BaseDataSchema = 'baseDataSchema',\r\n\r\n  // DPI_DataSchema, having type DataSchemaPresModel\r\n  DataSchema = 'dataSchema',\r\n\r\n  // DPI_SchemaViewerDataSchema, having type SchemaViewerDataSchemaPresModel\r\n  SchemaViewerDataSchema = 'schemaViewerDataSchema',\r\n\r\n  // DPI_SheetListItem, having type SheetListItemPresModel\r\n  SheetListItem = 'sheetListItem',\r\n\r\n  // DPI_SheetListItems, having type SheetListItemPresModel[]\r\n  SheetListItems = 'sheetListItems',\r\n\r\n  // DPI_SheetList, having type SheetListPresModel\r\n  SheetList = 'sheetList',\r\n\r\n  // DPI_SizeModeOption, having type SizeModeOptionPresModel\r\n  SizeModeOption = 'sizeModeOption',\r\n\r\n  // DPI_SizeModeOptions, having type SizeModeOptionPresModel[]\r\n  SizeModeOptions = 'sizeModeOptions',\r\n\r\n  // DPI_DashboardSizeControl, having type DashboardSizeControlPresModel\r\n  DashboardSizeControl = 'dashboardSizeControl',\r\n\r\n  // DPI_DeviceLayoutInfoItem, having type DeviceLayoutInfoItemPresModel\r\n  DeviceLayoutInfoItem = 'deviceLayoutInfoItem',\r\n\r\n  // DPI_DeviceLayoutInfoItems, having type DeviceLayoutInfoItemPresModel[]\r\n  DeviceLayoutInfoItems = 'deviceLayoutInfoItems',\r\n\r\n  // DPI_DeviceLayoutInfoList, having type DeviceLayoutInfoListPresModel\r\n  DeviceLayoutInfoList = 'deviceLayoutInfoList',\r\n\r\n  // DPI_SpecializedDeviceLayoutItem, having type SpecializedDeviceLayoutItemPresModel\r\n  SpecializedDeviceLayoutItem = 'specializedDeviceLayoutItem',\r\n\r\n  // DPI_SpecializedDeviceLayoutItems, having type SpecializedDeviceLayoutItemPresModel[]\r\n  SpecializedDeviceLayoutItems = 'specializedDeviceLayoutItems',\r\n\r\n  // DPI_SpecializedDeviceLayoutList, having type SpecializedDeviceLayoutListPresModel\r\n  SpecializedDeviceLayoutList = 'specializedDeviceLayoutList',\r\n\r\n  // DPI_SizeItem, having type SizeItemPresModel\r\n  SizeItem = 'sizeItem',\r\n\r\n  // DPI_SizeItems, having type SizeItemPresModel[]\r\n  SizeItems = 'sizeItems',\r\n\r\n  // DPI_DeviceSizesList, having type SizeItemListPresModel\r\n  DeviceSizesList = 'deviceSizesList',\r\n\r\n  // DPI_PresetSizesList, having type SizeItemListPresModel\r\n  PresetSizesList = 'presetSizesList',\r\n\r\n  // DPI_SizeItemList, having type SizeItemListPresModel\r\n  SizeItemList = 'sizeItemList',\r\n\r\n  // DPI_SubstitutionKeyword, having type SubstitutionKeywordPresModel\r\n  SubstitutionKeyword = 'substitutionKeyword',\r\n\r\n  // DPI_SubstitutionKeywords, having type SubstitutionKeywordPresModel[]\r\n  SubstitutionKeywords = 'substitutionKeywords',\r\n\r\n  // DPI_SubstitutionKeywordSubList, having type SubstitutionKeywordSubListPresModel\r\n  SubstitutionKeywordSubList = 'substitutionKeywordsSublist',\r\n\r\n  // DPI_SubstitutionKeywordSubLists, having type SubstitutionKeywordSubListPresModel[]\r\n  SubstitutionKeywordSubLists = 'substitutionKeywordSublists',\r\n\r\n  // DPI_SubstitutionKeywordList, having type SubstitutionKeywordListPresModel\r\n  SubstitutionKeywordList = 'substitutionKeywordsList',\r\n\r\n  // DPI_DeviceZoneListItem, having type DeviceZoneListItemPresModel\r\n  DeviceZoneListItem = 'deviceZoneListItem',\r\n\r\n  // DPI_DeviceZoneListItems, having type DeviceZoneListItemPresModel[]\r\n  DeviceZoneListItems = 'deviceZoneListItems',\r\n\r\n  // DPI_DeviceZoneList, having type DeviceZoneListPresModel\r\n  DeviceZoneList = 'deviceZoneList',\r\n\r\n  // DPI_ZoneSnapLineListItem, having type ZoneSnapLineListItemPresModel\r\n  ZoneSnapLineListItem = 'snapLineListItem',\r\n\r\n  // DPI_OuterHorizontalSnapLines, having type ZoneSnapLineListItemPresModel[]\r\n  OuterHorizontalSnapLines = 'outerHorizontalSnapLines',\r\n\r\n  // DPI_OuterVerticalSnapLines, having type ZoneSnapLineListItemPresModel[]\r\n  OuterVerticalSnapLines = 'outerVerticalSnapLines',\r\n\r\n  // DPI_InnerHorizontalSnapLines, having type ZoneSnapLineListItemPresModel[]\r\n  InnerHorizontalSnapLines = 'innerHorizontalSnapLines',\r\n\r\n  // DPI_InnerVerticalSnapLines, having type ZoneSnapLineListItemPresModel[]\r\n  InnerVerticalSnapLines = 'innerVerticalSnapLines',\r\n\r\n  // DPI_ZoneSnapLineList, having type ZoneSnapLineListPresModel\r\n  ZoneSnapLineList = 'snapLineList',\r\n\r\n  // DPI_DashboardZoneHierarchy, having type DashboardZoneHierarchyPresModel\r\n  DashboardZoneHierarchy = 'dashboardZoneHierarchy',\r\n\r\n  // DPI_DeviceZoneVisibilityListItem, having type DeviceZoneVisibilityListItemPresModel\r\n  DeviceZoneVisibilityListItem = 'deviceZoneVisibilityListItem',\r\n\r\n  // DPI_DeviceZoneVisibilityListItems, having type DeviceZoneVisibilityListItemPresModel[]\r\n  DeviceZoneVisibilityListItems = 'deviceZoneVisibilityListItems',\r\n\r\n  // DPI_DeviceZoneVisibilityList, having type DeviceZoneVisibilityListPresModel\r\n  DeviceZoneVisibilityList = 'deviceZoneVisibilityList',\r\n\r\n  // DPI_WorksheetDataSchema, having type WorksheetDataSchemaPresModel\r\n  WorksheetDataSchema = 'worksheetDataSchema',\r\n\r\n  // DPI_WorksheetDataSchemaMap, having type Dictionary(of WorksheetDataSchemaPresModel)\r\n  WorksheetDataSchemaMap = 'worksheetDataSchemaMap',\r\n\r\n  // DPI_Shelf, having type ShelfPresModel\r\n  Shelf = 'shelf',\r\n\r\n  // DPI_ShelfDetail, having type ShelfPresModel\r\n  ShelfDetail = 'shelfDetail',\r\n\r\n  // DPI_ShelfList, having type ShelfPresModel[]\r\n  ShelfList = 'shelfList',\r\n\r\n  // DPI_ShelfItem, having type ShelfItemPresModel\r\n  ShelfItem = 'shelfItem',\r\n\r\n  // DPI_ShelfItems, having type ShelfItemPresModel[]\r\n  ShelfItems = 'shelfItems',\r\n\r\n  // DPI_Shelves, having type ShelvesPresModel\r\n  Shelves = 'shelves',\r\n\r\n  // DPI_FieldEncoding, having type FieldEncodingPresModel\r\n  FieldEncoding = 'fieldEncoding',\r\n\r\n  // DPI_FieldEncodings, having type FieldEncodingPresModel[]\r\n  FieldEncodings = 'fieldEncodings',\r\n\r\n  // DPI_UberTip, having type UberTipPresModel\r\n  UberTip = 'uberTip',\r\n\r\n  // DPI_AnalyticsObjectDragInfo, having type AnalyticsObjectDragInfoPresModel\r\n  AnalyticsObjectDragInfo = 'analyticsObjectDragInfo',\r\n\r\n  // DPI_TrendLine, having type TrendLinePresModel\r\n  TrendLine = 'trendLine',\r\n\r\n  // DPI_TrendLineDialog, having type TrendLineDialogPresModel\r\n  TrendLineDialog = 'trendLineDialog',\r\n\r\n  // DPI_TrendLineDescribePresModel, having type TrendLineDescribePresModel\r\n  TrendLineDescribePresModel = 'trendLineDescribePresModel',\r\n\r\n  // DPI_TrendLineAOVModelPresModel, having type TrendLineAOVModelPresModel\r\n  TrendLineAOVModelPresModel = 'trendLineAovModelPresModel',\r\n\r\n  // DPI_TrendLineAOVModelsPresModel, having type TrendLineAOVModelPresModel[]\r\n  TrendLineAOVModelsPresModel = 'trendModelDescriptionVector',\r\n\r\n  // DPI_TrendLineLineCoefficientPresModel, having type TrendLineLineCoefficientPresModel\r\n  TrendLineLineCoefficientPresModel = 'trendLineLineCoefficient',\r\n\r\n  // DPI_TrendLineLineCoefficientsPresModel, having type TrendLineLineCoefficientPresModel[]\r\n  TrendLineLineCoefficientsPresModel = 'trendLineLineCoefficientsPresModel',\r\n\r\n  // DPI_TrendLineLinesPresModel, having type TrendLineLinesPresModel\r\n  TrendLineLinesPresModel = 'trendLineLinesPresModel',\r\n\r\n  // DPI_TrendLineAOVPresModel, having type TrendLineAOVPresModel\r\n  TrendLineAOVPresModel = 'trendLineAnovaPresModel',\r\n\r\n  // DPI_ReferenceLine, having type ReferenceLinePresModel\r\n  ReferenceLine = 'referenceLine',\r\n\r\n  // DPI_ReferenceLines, having type ReferenceLinePresModel[]\r\n  ReferenceLines = 'referenceLines',\r\n\r\n  // DPI_PercentileEditDataValue, having type EditDataValuePresModel\r\n  PercentileEditDataValue = 'percentileEditDataValue',\r\n\r\n  // DPI_LimitEditDataValue, having type EditDataValuePresModel\r\n  LimitEditDataValue = 'limitEditDataValue',\r\n\r\n  // DPI_ConfidenceLevelCombo, having type EditValueWidgetPresModel\r\n  ConfidenceLevelCombo = 'confidenceLevelCombo',\r\n\r\n  // DPI_DistributionQuantilesCombo, having type EditValueWidgetPresModel\r\n  DistributionQuantilesCombo = 'distributionQuantilesLevelCombo',\r\n\r\n  // DPI_PercentilesCombo, having type EditValueWidgetPresModel\r\n  PercentilesCombo = 'distributionPercentilesLevelCombo',\r\n\r\n  // DPI_NumericBinSizeCombo, having type EditValueWidgetPresModel\r\n  NumericBinSizeCombo = 'numericBinSizeCombo',\r\n\r\n  // DPI_FieldPickerField, having type FieldPickerFieldPresModel\r\n  FieldPickerField = 'fieldPickerField',\r\n\r\n  // DPI_FieldPickerFields, having type FieldPickerFieldPresModel[]\r\n  FieldPickerFields = 'fieldPickerFields',\r\n\r\n  // DPI_FieldPickerCombo, having type FieldPickerComboPresModel\r\n  FieldPickerCombo = 'fieldPickerCombo',\r\n\r\n  // DPI_PairedFieldPickerCombo, having type FieldPickerComboPresModel\r\n  PairedFieldPickerCombo = 'pairedFieldPickerCombo',\r\n\r\n  // DPI_ReferenceLineEditorPresModel, having type ReferenceLineEditorPresModel\r\n  ReferenceLineEditorPresModel = 'referenceLineEditor',\r\n\r\n  // DPI_CloseDataSourceErrorDialogPresModel, having type CloseDataSourceErrorDialogPresModel\r\n  CloseDataSourceErrorDialogPresModel = 'closeDsErrorDialog',\r\n\r\n  // DPI_EditReferenceLine, having type EditReferenceLinePresModel\r\n  EditReferenceLine = 'editReferenceLine',\r\n\r\n  // DPI_EditReferenceBand, having type EditReferenceBandPresModel\r\n  EditReferenceBand = 'editReferenceBand',\r\n\r\n  // DPI_EditDistribution, having type EditDistributionPresModel\r\n  EditDistribution = 'editDistribution',\r\n\r\n  // DPI_DistributionPercentages, having type DistributionPercentagesPresModel\r\n  DistributionPercentages = 'distributionPercentages',\r\n\r\n  // DPI_DistributionPercentiles, having type DistributionPercentilesPresModel\r\n  DistributionPercentiles = 'distributionPercentiles',\r\n\r\n  // DPI_DistributionQuantiles, having type DistributionQuantilesPresModel\r\n  DistributionQuantiles = 'distributionQuantiles',\r\n\r\n  // DPI_DistributionStandardDeviation, having type DistributionStandardDeviationPresModel\r\n  DistributionStandardDeviation = 'distributionStddev',\r\n\r\n  // DPI_SortIndicators, having type SortIndicatorsPresModel\r\n  SortIndicators = 'sortIndicators',\r\n\r\n  // DPI_SortIndicatorRegion, having type SortIndicatorRegionPresModel\r\n  SortIndicatorRegion = 'sortIndicatorRegion',\r\n\r\n  // DPI_SortIndicatorRegions, having type SortIndicatorRegionPresModel[]\r\n  SortIndicatorRegions = 'sortIndicatorRegions',\r\n\r\n  // DPI_SortIndicatorItem, having type SortIndicatorItemPresModel\r\n  SortIndicatorItem = 'sortIndicatorItem',\r\n\r\n  // DPI_SortIndicatorItems, having type SortIndicatorItemPresModel[]\r\n  SortIndicatorItems = 'sortIndicatorItems',\r\n\r\n  // DPI_BuilderConfig, having type BuilderConfigPresModel\r\n  BuilderConfig = 'builderConfig',\r\n\r\n  // DPI_SheetLayoutInfo, having type SheetLayoutInfoPresModel\r\n  SheetLayoutInfo = 'sheetLayoutInfo',\r\n\r\n  // DPI_AreaRect, having type RectanglePresModel\r\n  AreaRect = 'areaRect',\r\n\r\n  // DPI_Border, having type RectanglePresModel\r\n  Border = 'borderRect',\r\n\r\n  // DPI_BoundsRect, having type RectanglePresModel\r\n  BoundsRect = 'boundsRect',\r\n\r\n  // DPI_ButtonRect, having type RectanglePresModel\r\n  ButtonRect = 'buttonRect',\r\n\r\n  // DPI_DragRect, having type RectanglePresModel\r\n  DragRect = 'dragRect',\r\n\r\n  // DPI_FocusRect, having type RectanglePresModel\r\n  FocusRect = 'focusRect',\r\n\r\n  // DPI_ImageTileRect, having type RectanglePresModel\r\n  ImageTileRect = 'tileRect',\r\n\r\n  // DPI_ItemRect, having type RectanglePresModel\r\n  ItemRect = 'itemRect',\r\n\r\n  // DPI_LabelRect, having type RectanglePresModel\r\n  LabelRect = 'labelRect',\r\n\r\n  // DPI_MarkRect, having type RectanglePresModel\r\n  MarkRect = 'markRect',\r\n\r\n  // DPI_MarkTooltipRect, having type RectanglePresModel\r\n  MarkTooltipRect = 'markTooltipRect',\r\n\r\n  // DPI_MenuButtonRect, having type RectanglePresModel\r\n  MenuButtonRect = 'menuButtonRect',\r\n\r\n  // DPI_OutRegionRect, having type RectanglePresModel\r\n  OutRegionRect = 'outRegionRect',\r\n\r\n  // DPI_PaneRect, having type RectanglePresModel\r\n  PaneRect = 'paneRect',\r\n\r\n  // DPI_PixelExtents, having type RectanglePresModel\r\n  PixelExtents = 'pixelExtents',\r\n\r\n  // DPI_RectMaxLabel, having type RectanglePresModel\r\n  RectMaxLabel = 'rectMaxLabel',\r\n\r\n  // DPI_RectMinLabel, having type RectanglePresModel\r\n  RectMinLabel = 'rectMinLabel',\r\n\r\n  // DPI_RectRamp, having type RectanglePresModel\r\n  RectRamp = 'rectRamp',\r\n\r\n  // DPI_RectTitle, having type RectanglePresModel\r\n  RectTitle = 'rectTitle',\r\n\r\n  // DPI_RegionRect, having type RectanglePresModel\r\n  RegionRect = 'regionRect',\r\n\r\n  // DPI_SelectionRect, having type RectanglePresModel\r\n  SelectionRect = 'selectionRect',\r\n\r\n  // DPI_UnusedRect, having type RectanglePresModel\r\n  UnusedRect = 'unusedRect',\r\n\r\n  // DPI_ZoneEdgeRect, having type RectanglePresModel\r\n  ZoneEdgeRect = 'zoneEdge',\r\n\r\n  // DPI_ZoneEdgeRectPix, having type RectanglePresModel\r\n  ZoneEdgeRectPix = 'zoneEdgePix',\r\n\r\n  // DPI_ZoneEdgeRectPp, having type RectanglePresModel\r\n  ZoneEdgeRectPp = 'zoneEdgePp',\r\n\r\n  // DPI_UIAutomationLinkRect, having type RectanglePresModel\r\n  UIAutomationLinkRect = 'linkRect',\r\n\r\n  // DPI_Borders, having type RectanglePresModel[]\r\n  Borders = 'borderRects',\r\n\r\n  // DPI_UIAutomationLinkRects, having type RectanglePresModel[]\r\n  UIAutomationLinkRects = 'linkRects',\r\n\r\n  // DPI_DomainExtents, having type DoubleRectanglePresModel\r\n  DomainExtents = 'domainExtents',\r\n\r\n  // DPI_MapDomainExtents, having type DoubleRectanglePresModel\r\n  MapDomainExtents = 'mapDomainExtents',\r\n\r\n  // DPI_MapLatLongRect, having type MapRectPresModel\r\n  MapLatLongRect = 'mapLatLongRect',\r\n\r\n  // DPI_Center, having type PointPresModel\r\n  Center = 'center',\r\n\r\n  // DPI_CenterMarkLineBegin, having type PointPresModel\r\n  CenterMarkLineBegin = 'centerMarkLineBegin',\r\n\r\n  // DPI_CenterMarkLineEnd, having type PointPresModel\r\n  CenterMarkLineEnd = 'centerMarkLineEnd',\r\n\r\n  // DPI_DropLocation, having type PointPresModel\r\n  DropLocation = 'dropLocation',\r\n\r\n  // DPI_EndPt, having type PointPresModel\r\n  EndPt = 'endPoint',\r\n\r\n  // DPI_GrabLocation, having type PointPresModel\r\n  GrabLocation = 'grabLocation',\r\n\r\n  // DPI_GridOrigin, having type PointPresModel\r\n  GridOrigin = 'gridOrigin',\r\n\r\n  // DPI_LassoSelectionPoint, having type PointPresModel\r\n  LassoSelectionPoint = 'lassoSelectionPoint',\r\n\r\n  // DPI_MenuLocation, having type PointPresModel\r\n  MenuLocation = 'menuLocation',\r\n\r\n  // DPI_MoveOffset, having type PointPresModel\r\n  MoveOffset = 'moveOffset',\r\n\r\n  // DPI_OverlayAnchor, having type PointPresModel\r\n  OverlayAnchor = 'overlayAnchor',\r\n\r\n  // DPI_PanAmount, having type PointPresModel\r\n  PanAmount = 'panAmount',\r\n\r\n  // DPI_PanLocation, having type PointPresModel\r\n  PanLocation = 'panLocation',\r\n\r\n  // DPI_PaneResolverLocation, having type PointPresModel\r\n  PaneResolverLocation = 'paneResolverLocation',\r\n\r\n  // DPI_PixelExtentsOffset, having type PointPresModel\r\n  PixelExtentsOffset = 'extentsOffset',\r\n\r\n  // DPI_Point1, having type PointPresModel\r\n  Point1 = 'pt1',\r\n\r\n  // DPI_Point2, having type PointPresModel\r\n  Point2 = 'pt2',\r\n\r\n  // DPI_Point3, having type PointPresModel\r\n  Point3 = 'pt3',\r\n\r\n  // DPI_RegionPoint, having type PointPresModel\r\n  RegionPoint = 'regionPoint',\r\n\r\n  // DPI_ScrollOffset, having type PointPresModel\r\n  ScrollOffset = 'scrollOffset',\r\n\r\n  // DPI_SelectAtPoint, having type PointPresModel\r\n  SelectAtPoint = 'selectAtPoint',\r\n\r\n  // DPI_SelectOffset, having type PointPresModel\r\n  SelectOffset = 'selectOffset',\r\n\r\n  // DPI_TargetPt, having type PointPresModel\r\n  TargetPt = 'targetPoint',\r\n\r\n  // DPI_TextOrigin, having type PointPresModel\r\n  TextOrigin = 'textOrigin',\r\n\r\n  // DPI_TooltipAnchorPoint, having type PointPresModel\r\n  TooltipAnchorPoint = 'tooltipAnchorPoint',\r\n\r\n  // DPI_TooltipOffset, having type PointPresModel\r\n  TooltipOffset = 'tooltipOffset',\r\n\r\n  // DPI_VizLocation, having type PointPresModel\r\n  VizLocation = 'vizLocation',\r\n\r\n  // DPI_ZoomAnchorPoint, having type PointPresModel\r\n  ZoomAnchorPoint = 'zoomAnchorPoint',\r\n\r\n  // DPI_MenuAnchorPoint, having type PointPresModel\r\n  MenuAnchorPoint = 'menuAnchorPoint',\r\n\r\n  // DPI_OverlayAnchors, having type PointPresModel[]\r\n  OverlayAnchors = 'overlayAnchors',\r\n\r\n  // DPI_LassoSelection, having type PointPresModel[]\r\n  LassoSelection = 'lassoSelection',\r\n\r\n  // DPI_ScrollOffsetPoints, having type PointPresModel[]\r\n  ScrollOffsetPoints = 'scrollOffsetPoints',\r\n\r\n  // DPI_RadialSelection, having type CirclePresModel\r\n  RadialSelection = 'radialSelection',\r\n\r\n  // DPI_DomainOrigin, having type FloatPointPresModel\r\n  DomainOrigin = 'domainOrigin',\r\n\r\n  // DPI_FloatCenter, having type FloatPointPresModel\r\n  FloatCenter = 'floatCenter',\r\n\r\n  // DPI_FloatPoint, having type FloatPointPresModel\r\n  FloatPoint = 'floatPoint',\r\n\r\n  // DPI_ClientAvailableSpace, having type SizePresModel\r\n  ClientAvailableSpace = 'clientAvailableSpace',\r\n\r\n  // DPI_DashboardPortSize, having type SizePresModel\r\n  DashboardPortSize = 'dashboardPort',\r\n\r\n  // DPI_LegendSize, having type SizePresModel\r\n  LegendSize = 'legendSize',\r\n\r\n  // DPI_StoryPortSize, having type SizePresModel\r\n  StoryPortSize = 'storyPort',\r\n\r\n  // DPI_SwatchAreaSize, having type SizePresModel\r\n  SwatchAreaSize = 'areaSize',\r\n\r\n  // DPI_SwatchImageSize, having type SizePresModel\r\n  SwatchImageSize = 'imageSize',\r\n\r\n  // DPI_ViewportSize, having type SizePresModel\r\n  ViewportSize = 'viewportSize',\r\n\r\n  // DPI_WorksheetPortSize, having type SizePresModel\r\n  WorksheetPortSize = 'worksheetPort',\r\n\r\n  // DPI_ResizeEntity, having type ResizeEntityPresModel\r\n  ResizeEntity = 'resizeEntity',\r\n\r\n  // DPI_RowResizers, having type ResizeEntityPresModel[]\r\n  RowResizers = 'rowResizers',\r\n\r\n  // DPI_ColResizers, having type ResizeEntityPresModel[]\r\n  ColResizers = 'colResizers',\r\n\r\n  // DPI_ResizeInfoPresModel, having type ResizeInfoPresModel\r\n  ResizeInfoPresModel = 'resizeInfo',\r\n\r\n  // DPI_ServerSheet, having type ServerSheetPresModel\r\n  ServerSheet = 'serverSheet',\r\n\r\n  // DPI_ServerSheets, having type ServerSheetPresModel[]\r\n  ServerSheets = 'serverSheets',\r\n\r\n  // DPI_SheetInfo, having type SheetInfoPresModel\r\n  SheetInfo = 'sheetInfo',\r\n\r\n  // DPI_SheetsInfo, having type SheetInfoPresModel[]\r\n  SheetsInfo = 'sheetsInfo',\r\n\r\n  // DPI_ServerWorkbook, having type ServerWorkbookPresModel\r\n  ServerWorkbook = 'serverWorkbook',\r\n\r\n  // DPI_PDFExportOptionsPresModel, having type PDFExportOptionsPresModel\r\n  PDFExportOptionsPresModel = 'pdfExport',\r\n\r\n  // DPI_ExportFileResultPresModel, having type ExportFileResultPresModel\r\n  ExportFileResultPresModel = 'pdfResult',\r\n\r\n  // DPI_PDFSheet, having type PDFSheetPresModel\r\n  PDFSheet = 'pdfSheet',\r\n\r\n  // DPI_SheetOptions, having type PDFSheetPresModel[]\r\n  SheetOptions = 'sheetOptions',\r\n\r\n  // DPI_ExportLayoutOptions, having type ExportLayoutOptionsPresModel\r\n  ExportLayoutOptions = 'exportLayoutOptions',\r\n\r\n  // DPI_DataAlertConditionOperationType, having type DataAlertConditionOperationType\r\n  DataAlertConditionOperationType = 'dataAlertConditionOp',\r\n\r\n  // DPI_DataAlertDialogPresModel, having type DataAlertDialogPresModel\r\n  DataAlertDialogPresModel = 'dataAlertDialogPresModel',\r\n\r\n  // DPI_DataAlertMeasure, having type DataAlertMeasurePresModel\r\n  DataAlertMeasure = 'dataAlertMeasure',\r\n\r\n  // DPI_DataAlertMeasures, having type DataAlertMeasurePresModel[]\r\n  DataAlertMeasures = 'dataAlertMeasures',\r\n\r\n  // DPI_DataAlertConstantCondition, having type DataAlertConstantConditionPresModel\r\n  DataAlertConstantCondition = 'dataAlertConstantCondition',\r\n\r\n  // DPI_DataAlertDialogMode, having type DataAlertDialogMode\r\n  DataAlertDialogMode = 'dataAlertDialogMode',\r\n\r\n  // DPI_LightweightMapOptions, having type LightweightMapOptionsPresModel\r\n  LightweightMapOptions = 'lightweightMapOptions',\r\n\r\n  // DPI_DataHighlighter, having type DataHighlighterPresModel\r\n  DataHighlighter = 'dataHighlighter',\r\n\r\n  // DPI_DataHighlighterItemSet, having type DataHighlighterItemSetPresModel\r\n  DataHighlighterItemSet = 'dataHighlighterItemSet',\r\n\r\n  // DPI_DataHighlighterItem, having type DataHighlighterItemPresModel\r\n  DataHighlighterItem = 'dataHighlighterItem',\r\n\r\n  // DPI_DataHighlighterItems, having type DataHighlighterItemPresModel[]\r\n  DataHighlighterItems = 'dataHighlighterItems',\r\n\r\n  // DPI_CategoricalLegendLayout, having type CategoricalLegendLayoutPresModel\r\n  CategoricalLegendLayout = 'catLegendLayout',\r\n\r\n  // DPI_CategoricalLegend, having type CategoricalLegendPresModel\r\n  CategoricalLegend = 'categoricalLegend',\r\n\r\n  // DPI_CategoricalLegends, having type CategoricalLegendPresModel[]\r\n  CategoricalLegends = 'categoricalLegends',\r\n\r\n  // DPI_CategoricalColorLegend, having type CategoricalColorLegendPresModel\r\n  CategoricalColorLegend = 'colorLegend',\r\n\r\n  // DPI_ColorLegendItem, having type CategoricalColorLegendItemPresModel\r\n  ColorLegendItem = 'colorLegendItem',\r\n\r\n  // DPI_ColorLegendItems, having type CategoricalColorLegendItemPresModel[]\r\n  ColorLegendItems = 'colorLegendItems',\r\n\r\n  // DPI_CategoricalShapeLegend, having type CategoricalShapeLegendPresModel\r\n  CategoricalShapeLegend = 'categoricalShapeLegend',\r\n\r\n  // DPI_ShapeLegendItem, having type CategoricalShapeLegendItemPresModel\r\n  ShapeLegendItem = 'shapeLegendItem',\r\n\r\n  // DPI_ShapeLegendItems, having type CategoricalShapeLegendItemPresModel[]\r\n  ShapeLegendItems = 'shapeLegendItems',\r\n\r\n  // DPI_CategoricalHighlightLegend, having type CategoricalHighlightLegendPresModel\r\n  CategoricalHighlightLegend = 'categoricalHighlightLegend',\r\n\r\n  // DPI_HighlightLegendItem, having type CategoricalLegendItemPresModel\r\n  HighlightLegendItem = 'highlightLegendItem',\r\n\r\n  // DPI_HighlightLegendItems, having type CategoricalLegendItemPresModel[]\r\n  HighlightLegendItems = 'highlightLegendItems',\r\n\r\n  // DPI_CategoricalSizeLegend, having type CategoricalSizeLegendPresModel\r\n  CategoricalSizeLegend = 'categoricalSizeLegend',\r\n\r\n  // DPI_SizeLegendItem, having type CategoricalSizeLegendItemPresModel\r\n  SizeLegendItem = 'sizeLegendItem',\r\n\r\n  // DPI_SizeLegendItems, having type CategoricalSizeLegendItemPresModel[]\r\n  SizeLegendItems = 'sizeLegendItems',\r\n\r\n  // DPI_CategoricalMapLegend, having type CategoricalMapLegendPresModel\r\n  CategoricalMapLegend = 'categoricalMapLegend',\r\n\r\n  // DPI_QuantitativeColorLegend, having type QuantitativeColorLegendPresModel\r\n  QuantitativeColorLegend = 'quantitativeColorLegend',\r\n\r\n  // DPI_QuantitativeColorLegends, having type QuantitativeColorLegendPresModel[]\r\n  QuantitativeColorLegends = 'quantitativeColorLegends',\r\n\r\n  // DPI_QuantitativeLegendLayout, having type QuantitativeLegendLayoutPresModel\r\n  QuantitativeLegendLayout = 'quantitativeLegendLayout',\r\n\r\n  // DPI_ServerRenderedLegend, having type ServerRenderedLegendPresModel\r\n  ServerRenderedLegend = 'serverRenderedLegend',\r\n\r\n  // DPI_CategoricalFilter, having type CategoricalFilterPresModel\r\n  CategoricalFilter = 'categoricalFilter',\r\n\r\n  // DPI_CategoricalFilterRelational, having type CategoricalFilterRelationalPresModel\r\n  CategoricalFilterRelational = 'categoricalFilterRelational',\r\n\r\n  // DPI_CategoricalFilterMemberDomainPage, having type CategoricalFilterMemberDomainPagePresModel\r\n  CategoricalFilterMemberDomainPage = 'categoricalFilterMemberDomainPage',\r\n\r\n  // DPI_CategoricalFilterCacheInfo, having type CategoricalFilterCacheInfoPresModel\r\n  CategoricalFilterCacheInfo = 'categoricalFilterCacheInfo',\r\n\r\n  // DPI_CategoricalFilterPatternDisplay, having type CategoricalFilterPatternDisplayPresModel\r\n  CategoricalFilterPatternDisplay = 'categoricalFilterPatternDisplay',\r\n\r\n  // DPI_CategoricalFilterPatternUpdate, having type CategoricalFilterPatternUpdatePresModel\r\n  CategoricalFilterPatternUpdate = 'categoricalFilterPatternUpdate',\r\n\r\n  // DPI_CategoricalFilterConditionDisplay, having type CategoricalFilterConditionDisplayPresModel\r\n  CategoricalFilterConditionDisplay = 'categoricalFilterConditionDisplay',\r\n\r\n  // DPI_CategoricalFilterConditionUpdate, having type CategoricalFilterConditionUpdatePresModel\r\n  CategoricalFilterConditionUpdate = 'categoricalFilterConditionUpdate',\r\n\r\n  // DPI_CategoricalFilterLimitDisplay, having type CategoricalFilterLimitDisplayPresModel\r\n  CategoricalFilterLimitDisplay = 'categoricalFilterLimitDisplay',\r\n\r\n  // DPI_CategoricalFilterLimitUpdate, having type CategoricalFilterLimitUpdatePresModel\r\n  CategoricalFilterLimitUpdate = 'categoricalFilterLimitUpdate',\r\n\r\n  // DPI_CategoricalFilterNew, having type CategoricalFilter_NewPresModel\r\n  CategoricalFilterNew = 'categoricalFilterNew',\r\n\r\n  // DPI_CategoricalFilterHierarchy, having type CategoricalFilterHierarchyPresModel\r\n  CategoricalFilterHierarchy = 'categoricalFilterHirerarchy',\r\n\r\n  // DPI_CategoricalFilterUpdate, having type CategoricalFilterUpdatePresModel\r\n  CategoricalFilterUpdate = 'categoricalFilterUpdate',\r\n\r\n  // DPI_CategoricalFilterRelationalState, having type CategoricalFilterRelationalStatePresModel\r\n  CategoricalFilterRelationalState = 'categoricalRelationalState',\r\n\r\n  // DPI_CategoricalFilterRelationalUpdatedState, having type CategoricalFilterRelationalStatePresModel\r\n  CategoricalFilterRelationalUpdatedState = 'categoricalRelationalUpdatedState',\r\n\r\n  // DPI_CategoricalFilterRelationalDomainInfo, having type CategoricalFilterRelationalDomainInfoPresModel\r\n  CategoricalFilterRelationalDomainInfo = 'categoricalFilterRelationalDomainInfo',\r\n\r\n  // DPI_CategoricalFilterRelationalDisplay, having type CategoricalFilterRelationalDisplayPresModel\r\n  CategoricalFilterRelationalDisplay = 'categoricalFilterRelationalDisplay',\r\n\r\n  // DPI_ExpressionToken, having type ExpressionTokenPresModel\r\n  ExpressionToken = 'expressionToken',\r\n\r\n  // DPI_ExpressionTokens, having type ExpressionTokenPresModel[]\r\n  ExpressionTokens = 'expressionTokens',\r\n\r\n  // DPI_FormulaValidation, having type FormulaValidationPresModel\r\n  FormulaValidation = 'formulaValidation',\r\n\r\n  // DPI_CaptionedFilterValue, having type FilterValuePresModel\r\n  CaptionedFilterValue = 'captionedFilterValue',\r\n\r\n  // DPI_CaptionedRangeMin, having type FilterValuePresModel\r\n  CaptionedRangeMin = 'captionedRangeMin',\r\n\r\n  // DPI_CaptionedRangeMax, having type FilterValuePresModel\r\n  CaptionedRangeMax = 'captionedRangeMax',\r\n\r\n  // DPI_CaptionedAnchorDate, having type FilterValuePresModel\r\n  CaptionedAnchorDate = 'captionedAnchorDate',\r\n\r\n  // DPI_CaptionedFilterValueList, having type FilterValuePresModel[]\r\n  CaptionedFilterValueList = 'captionedFilterValueList',\r\n\r\n  // DPI_CategoricalFilterInfo, having type CategoricalFilterInfoPresModel\r\n  CategoricalFilterInfo = 'categoricalFilterInfo',\r\n\r\n  // DPI_QuantitativeFilterInfo, having type QuantitativeFilterInfoPresModel\r\n  QuantitativeFilterInfo = 'quantitativeFilterInfo',\r\n\r\n  // DPI_RelativeDateFilterInfo, having type RelativeDateFilterInfoPresModel\r\n  RelativeDateFilterInfo = 'relativeDateFilterInfo',\r\n\r\n  // DPI_FilterSelectMeasure, having type FilterSelectMeasurePresModel\r\n  FilterSelectMeasure = 'filterSelectMeasure',\r\n\r\n  // DPI_FilterListItem, having type FilterListItemPresModel\r\n  FilterListItem = 'filterListItem',\r\n\r\n  // DPI_FilterListItems, having type FilterListItemPresModel[]\r\n  FilterListItems = 'filterItems',\r\n\r\n  // DPI_FilterFieldInfo, having type FilterFieldInfoPresModel\r\n  FilterFieldInfo = 'filterFieldInfo',\r\n\r\n  // DPI_FilterInfo, having type FilterInfoPresModel\r\n  FilterInfo = 'filterInfo',\r\n\r\n  // DPI_FiltersInfo, having type FilterInforPresModel[]\r\n  FiltersInfo = 'filtersInfo',\r\n\r\n  // DPI_CategoricalDomain, having type CategoricalDomainPresModel\r\n  CategoricalDomain = 'categoricalDomain',\r\n\r\n  // DPI_QuantitativeDomain, having type QuantitativeDomainPresModel\r\n  QuantitativeDomain = 'quantitativeDomain',\r\n\r\n  // DPI_ValidationResults, having type ValidationResultsPresModel\r\n  ValidationResults = 'validationResults',\r\n\r\n  // DPI_DomainMember, having type DomainMemberPresModel\r\n  DomainMember = 'domainMember',\r\n\r\n  // DPI_DomainMembers, having type DomainMemberPresModel[]\r\n  DomainMembers = 'domainMembers',\r\n\r\n  // DPI_QuickFilterDisplay, having type QuickFilterDisplayPresModel\r\n  QuickFilterDisplay = 'quickFilterDisplay',\r\n\r\n  // DPI_QuickFilter, having type QuickFilterPresModel\r\n  QuickFilter = 'quickFilter',\r\n\r\n  // DPI_QuantitativeQuickFilter, having type QuantitativeQuickFilterPresModel\r\n  QuantitativeQuickFilter = 'quantitativeQuickFilter',\r\n\r\n  // DPI_RelativeDateQuickFilter, having type RelativeDateQuickFilterPresModel\r\n  RelativeDateQuickFilter = 'relativeDateQuickFilter',\r\n\r\n  // DPI_CategoricalQuickFilter, having type CategoricalQuickFilterPresModel\r\n  CategoricalQuickFilter = 'categoricalQuickFilter',\r\n\r\n  // DPI_HierarchicalQuickFilter, having type HierarchicalQuickFilterPresModel\r\n  HierarchicalQuickFilter = 'hierarchicalQuickFilter',\r\n\r\n  // DPI_DomainTable, having type DomainTablePresModel\r\n  DomainTable = 'domainTable',\r\n\r\n  // DPI_DomainTables, having type DomainTablePresModel[]\r\n  DomainTables = 'domainTables',\r\n\r\n  // DPI_DomainTuples, having type Tuples\r\n  DomainTuples = 'domainTuples',\r\n\r\n  // DPI_SearchTuples, having type Tuples\r\n  SearchTuples = 'searchTuples',\r\n\r\n  // DPI_SelectedTuples, having type TupleHash\r\n  SelectedTuples = 'selectedTuples',\r\n\r\n  // DPI_PendingTuples, having type TupleHash\r\n  PendingTuples = 'pendingTuples',\r\n\r\n  // DPI_Domain, having type MultiDomain\r\n  Domain = 'domain',\r\n\r\n  // DPI_DateOption, having type DateBinDialogOptionPresModel\r\n  DateOption = 'dateOption',\r\n\r\n  // DPI_DateOptions, having type DateBinDialogOptionPresModel[]\r\n  DateOptions = 'dateOptions',\r\n\r\n  // DPI_FilterRangeAdd, having type FilterRangePresModel\r\n  FilterRangeAdd = 'filterRangeAdd',\r\n\r\n  // DPI_FilterRangeRemove, having type FilterRangePresModel\r\n  FilterRangeRemove = 'filterRangeRemove',\r\n\r\n  // DPI_FilterOptions, having type FilterOptionsPresModel\r\n  FilterOptions = 'filterOptions',\r\n\r\n  // DPI_Layer, having type LayerPresModel\r\n  Layer = 'layer',\r\n\r\n  // DPI_Layers, having type LayerPresModel[]\r\n  Layers = 'layers',\r\n\r\n  // DPI_MarksCardPresModel, having type MarksCardPresModel\r\n  MarksCardPresModel = 'marksCardPresModel',\r\n\r\n  // DPI_UIItem, having type UIItemPresModel\r\n  UIItem = 'uiItem',\r\n\r\n  // DPI_EncodingUIItem, having type EncodingUIItemPresModel\r\n  EncodingUIItem = 'encodingUiItem',\r\n\r\n  // DPI_EncodingUIItems, having type EncodingUIItemPresModel[]\r\n  EncodingUIItems = 'encodingUiItems',\r\n\r\n  // DPI_PrimTypeUIItem, having type PrimitiveTypeUIItemPresModel\r\n  PrimTypeUIItem = 'primitiveTypeUiItem',\r\n\r\n  // DPI_PrimTypeUIItems, having type PrimitiveTypeUIItemPresModel[]\r\n  PrimTypeUIItems = 'primitiveTypeUiItems',\r\n\r\n  // DPI_PrimitiveTypeUIItemOptions, having type PrimitiveTypeUIItemOptionsPresModel\r\n  PrimitiveTypeUIItemOptions = 'primitiveTypeUiItemOptions',\r\n\r\n  // DPI_LineUIItemOptions, having type LineUIItemOptionsPresModel\r\n  LineUIItemOptions = 'lineUiItemOptions',\r\n\r\n  // DPI_LineInterpolationModeUIItem, having type LineInterpolationModeUIItemPresModel\r\n  LineInterpolationModeUIItem = 'lineInterpolationModeUiItem',\r\n\r\n  // DPI_LineInterpolationModeUIItemSet, having type LineInterpolationModeUIItemPresModel[]\r\n  LineInterpolationModeUIItemSet = 'lineInterpolationModeUiItemSet',\r\n\r\n  // DPI_LineMarkerPositionUIItem, having type LineMarkerPositionUIItemPresModel\r\n  LineMarkerPositionUIItem = 'lineMarkerPositionUiItem',\r\n\r\n  // DPI_LineMarkerPositionUIItemSet, having type LineMarkerPositionUIItemPresModel[]\r\n  LineMarkerPositionUIItemSet = 'lineMarkerPositionUiItemSet',\r\n\r\n  // DPI_MarksCardDropdownItem, having type MarksCardDropdownItemPresModel\r\n  MarksCardDropdownItem = 'marksCardDropdownItem',\r\n\r\n  // DPI_TooltipDropdownItem, having type TooltipDropdownItemPresModel\r\n  TooltipDropdownItem = 'tooltipDropdownItem',\r\n\r\n  // DPI_TextDropdownItem, having type TextDropdownItemPresModel\r\n  TextDropdownItem = 'textDropdownItem',\r\n\r\n  // DPI_ColorDropdownItem, having type ColorDropdownItemPresModel\r\n  ColorDropdownItem = 'colorDropdownItem',\r\n\r\n  // DPI_SizeSliderPresModel, having type SizeSliderPresModel\r\n  SizeSliderPresModel = 'sizeSliderPresModel',\r\n\r\n  // DPI_InflectionPoint, having type InflectionPointPresModel\r\n  InflectionPoint = 'inflectionPoint',\r\n\r\n  // DPI_InflectionPoints, having type InflectionPointPresModel[]\r\n  InflectionPoints = 'inflectionPoints',\r\n\r\n  // DPI_Notch, having type NotchPresModel\r\n  Notch = 'notch',\r\n\r\n  // DPI_Notches, having type NotchPresModel[]\r\n  Notches = 'notches',\r\n\r\n  // DPI_MarkSizeOptionsPresModel, having type MarkSizeOptionsPresModel\r\n  MarkSizeOptionsPresModel = 'markSizeOptionsPresModel',\r\n\r\n  // DPI_ModifyMarksInSet, having type AddOrRemoveMarks\r\n  ModifyMarksInSet = 'addOrRemoveMarks',\r\n\r\n  // DPI_MarkLabelsSpecification, having type MarkLabelsSpecificationPresModel\r\n  MarkLabelsSpecification = 'markLabelsSpecification',\r\n\r\n  // DPI_ColorPalette, having type ColorPalettePresModel\r\n  ColorPalette = 'colorPalette',\r\n\r\n  // DPI_SelectedColorPalette, having type ColorPalettePresModel\r\n  SelectedColorPalette = 'selectedColorPalette',\r\n\r\n  // DPI_ColorPalettes, having type ColorPalettePresModel[]\r\n  ColorPalettes = 'colorPalettes',\r\n\r\n  // DPI_ColorPaletteGroup, having type ColorPaletteGroupPresModel\r\n  ColorPaletteGroup = 'colorPaletteGroup',\r\n\r\n  // DPI_CatColorPaletteGroups, having type ColorPaletteGroupPresModel[]\r\n  CatColorPaletteGroups = 'catColorPaletteGroups',\r\n\r\n  // DPI_QColorPaletteGroups, having type ColorPaletteGroupPresModel[]\r\n  QColorPaletteGroups = 'qColorPaletteGroups',\r\n\r\n  // DPI_ColorPaletteCollection, having type ColorPaletteCollectionPresModel\r\n  ColorPaletteCollection = 'colorPaletteCollection',\r\n\r\n  // DPI_QuantitativeColor, having type QuantitativeColorPresModel\r\n  QuantitativeColor = 'quantitativeColor',\r\n\r\n  // DPI_CategoricalColor, having type CategoricalColorPresModel\r\n  CategoricalColor = 'categoricalColor',\r\n\r\n  // DPI_ItemColorPair, having type ItemColorPairPresModel\r\n  ItemColorPair = 'itemColorPair',\r\n\r\n  // DPI_ItemColorPairs, having type ItemColorPairPresModel[]\r\n  ItemColorPairs = 'itemColorPairs',\r\n\r\n  // DPI_VQLCommandResponse, having type VQLCommandResponsePresModel\r\n  VQLCommandResponse = 'vqlCmdResponse',\r\n\r\n  // DPI_LayoutStatus, having type LayoutStatusPresModel\r\n  LayoutStatus = 'layoutStatus',\r\n\r\n  // DPI_VizState, having type VizStatePresModel\r\n  VizState = 'vizState',\r\n\r\n  // DPI_VizStateList, having type VizStatePresModel[]\r\n  VizStateList = 'vizStateList',\r\n\r\n  // DPI_CommandResult, having type CommandResultPresModel\r\n  CommandResult = 'cmdResult',\r\n\r\n  // DPI_CommandResultList, having type CommandResultPresModel[]\r\n  CommandResultList = 'cmdResultList',\r\n\r\n  // DPI_URLAction, having type URLActionPresModel\r\n  URLAction = 'urlAction',\r\n\r\n  // DPI_URLActionList, having type URLActionPresModel[]\r\n  URLActionList = 'urlActionList',\r\n\r\n  // DPI_LegacyMenu, having type LegacyMenuPresModel\r\n  LegacyMenu = 'legacyMenu',\r\n\r\n  // DPI_LegacyMenus, having type LegacyMenuPresModel[]\r\n  LegacyMenus = 'legacyMenus',\r\n\r\n  // DPI_ConnectionAttemptInfo, having type ConnectionAttemptInfoPresModel\r\n  ConnectionAttemptInfo = 'connectionAttemptInfo',\r\n\r\n  // DPI_DataSourceConnectionAttemptInfo, having type DataSourceConnectionAttemptInfoPresModel\r\n  DataSourceConnectionAttemptInfo = 'dataSourceConnectionAttemptInfo',\r\n\r\n  // DPI_DataSourceConnectionAttemptInfos, having type DataSourceConnectionAttemptInfoPresModel[]\r\n  DataSourceConnectionAttemptInfos = 'dataSourceConnectionAttemptInfos',\r\n\r\n  // DPI_CommandValidationPresModel, having type CommandValidationPresModel\r\n  CommandValidationPresModel = 'commandValidationPresModel',\r\n\r\n  // DPI_WarningMessage, having type WarningMessagePresModel\r\n  WarningMessage = 'warningMessagePresModel',\r\n\r\n  // DPI_ApplicationPresModel, having type ApplicationPresModel\r\n  ApplicationPresModel = 'applicationPresModel',\r\n\r\n  // DPI_ToolbarPresModel, having type ToolbarPresModel\r\n  ToolbarPresModel = 'toolbarPresModel',\r\n\r\n  // DPI_WorkbookPresModel, having type WorkbookPresModel\r\n  WorkbookPresModel = 'workbookPresModel',\r\n\r\n  // DPI_ServerFonts, having type ServerFontsPresModel\r\n  ServerFonts = 'serverFonts',\r\n\r\n  // DPI_PublishDataSourceMetadataPresModel, having type PublishDataSourceMetadataPresModel\r\n  PublishDataSourceMetadataPresModel = 'publishDataSourceMetadataPresModel',\r\n\r\n  // DPI_DashboardPresModel, having type DashboardPresModel\r\n  DashboardPresModel = 'dashboardPresModel',\r\n\r\n  // DPI_DashboardSizePresModel, having type DashboardSizePresModel\r\n  DashboardSizePresModel = 'dashboardSizePresModel',\r\n\r\n  // DPI_DashboardSizeWithValidationPresModel, having type DashboardSizeWithValidationPresModel\r\n  DashboardSizeWithValidationPresModel = 'dashboardSizeWithValidationPresModel',\r\n\r\n  // DPI_DashboardInfoPresModel, having type DashboardInfoPresModel\r\n  DashboardInfoPresModel = 'dashboardInfoPresModel',\r\n\r\n  // DPI_VisualPresModel, having type VisualPresModel\r\n  VisualPresModel = 'visual',\r\n\r\n  // DPI_VisualPresModels, having type VisualPresModel[]\r\n  VisualPresModels = 'visuals',\r\n\r\n  // DPI_DropLinesPresModel, having type DropLinesPresModel\r\n  DropLinesPresModel = 'dropLinesPresModel',\r\n\r\n  // DPI_DropFieldPresModel, having type DropFieldPresModel\r\n  DropFieldPresModel = 'dropFieldPresModel',\r\n\r\n  // DPI_DropFieldResultPresModel, having type DropFieldResultPresModel\r\n  DropFieldResultPresModel = 'dropFieldResultPresModel',\r\n\r\n  // DPI_CurrentAxisRange, having type DataValueRangePresModel\r\n  CurrentAxisRange = 'currentAxisRange',\r\n\r\n  // DPI_CurrentAxisRangeNoTime, having type DataValueRangePresModel\r\n  CurrentAxisRangeNoTime = 'currentAxisRangeNoTime',\r\n\r\n  // DPI_DefaultAxisRange, having type DataValueRangePresModel\r\n  DefaultAxisRange = 'defaultAxisRange',\r\n\r\n  // DPI_NewAxisRange, having type DataValueRangePresModel\r\n  NewAxisRange = 'newAxisRange',\r\n\r\n  // DPI_AxisOptions, having type AxisOptionsPresModel\r\n  AxisOptions = 'axis',\r\n\r\n  // DPI_AxisMajorTicks, having type TickMarkInfoPresModel\r\n  AxisMajorTicks = 'axisMajorTicks',\r\n\r\n  // DPI_AxisMinorTicks, having type TickMarkInfoPresModel\r\n  AxisMinorTicks = 'axisMinorTicks',\r\n\r\n  // DPI_EditAxisDialog, having type EditAxisDialogPresModel\r\n  EditAxisDialog = 'editAxisDialog',\r\n\r\n  // DPI_MarkLabels, having type ScenePresModel\r\n  MarkLabels = 'markLabels',\r\n\r\n  // DPI_Scene, having type ScenePresModel\r\n  Scene = 'scene',\r\n\r\n  // DPI_MapServer, having type MapServerPresModel\r\n  MapServer = 'mapServer',\r\n\r\n  // DPI_VisualList, having type VisualListPresModel\r\n  VisualList = 'visualList',\r\n\r\n  // DPI_DrawFirst, having type VisualListPresModel[]\r\n  DrawFirst = 'drawFirst',\r\n\r\n  // DPI_DrawLast, having type VisualListPresModel[]\r\n  DrawLast = 'drawLast',\r\n\r\n  // DPI_DrawPane, having type VisualListPresModel[]\r\n  DrawPane = 'drawPane',\r\n\r\n  // DPI_UserPaneInfo, having type UserPaneInfoPresModel\r\n  UserPaneInfo = 'userPaneInfo',\r\n\r\n  // DPI_AnalyticsPane, having type AnalyticsPanePresModel\r\n  AnalyticsPane = 'analyticsPane',\r\n\r\n  // DPI_AnalyticsObjectItem, having type AnalyticsObjectItemPresModel\r\n  AnalyticsObjectItem = 'analyticsObjectItem',\r\n\r\n  // DPI_AnalyticsObjectItems, having type AnalyticsObjectItemPresModel[]\r\n  AnalyticsObjectItems = 'analyticsObjectItems',\r\n\r\n  // DPI_AnalyticsObjectGroup, having type AnalyticsObjectGroupPresModel\r\n  AnalyticsObjectGroup = 'analyticsObjectGroup',\r\n\r\n  // DPI_AnalyticsObjectGroups, having type AnalyticsObjectGroupPresModel[]\r\n  AnalyticsObjectGroups = 'analyticsObjectGroups',\r\n\r\n  // DPI_DropZoneItem, having type DropZoneItemPresModel\r\n  DropZoneItem = 'dropZoneItem',\r\n\r\n  // DPI_DropZoneItems, having type DropZoneItemPresModel[]\r\n  DropZoneItems = 'dropZoneItems',\r\n\r\n  // DPI_DropTargetInfo, having type DropTargetInfoPresModel\r\n  DropTargetInfo = 'dropTargetInfo',\r\n\r\n  // DPI_Pane, having type PanePresModel\r\n  Pane = 'pane',\r\n\r\n  // DPI_Panes, having type PanePresModel[]\r\n  Panes = 'panes',\r\n\r\n  // DPI_RadialSelectionDistanceInfo, having type RadialSelectionDistanceInfoPresModel\r\n  RadialSelectionDistanceInfo = 'radialSelectionDistanceInfo',\r\n\r\n  // DPI_MapScaleInfo, having type MapScaleInfoPresModel\r\n  MapScaleInfo = 'mapScaleInfo',\r\n\r\n  // DPI_RenderNode, having type RenderNodePresModel\r\n  RenderNode = 'renderNode',\r\n\r\n  // DPI_RenderNodes, having type RenderNodePresModel[]\r\n  RenderNodes = 'renderNodes',\r\n\r\n  // DPI_PredictionBand, having type PredictionBandPresModel\r\n  PredictionBand = 'predictionBand',\r\n\r\n  // DPI_PredictionWhisker, having type PredictionWhiskerPresModel\r\n  PredictionWhisker = 'predictionWhisker',\r\n\r\n  // DPI_DrawGroup, having type DrawPointsPresModel\r\n  DrawGroup = 'drawGroup',\r\n\r\n  // DPI_ClipReset, having type DrawItemPresModel\r\n  ClipReset = 'clipReset',\r\n\r\n  // DPI_DrawItem, having type DrawItemPresModel\r\n  DrawItem = 'drawItem',\r\n\r\n  // DPI_TransformPop, having type DrawItemPresModel\r\n  TransformPop = 'transformPop',\r\n\r\n  // DPI_TransformPush, having type DrawItemPresModel\r\n  TransformPush = 'transformPush',\r\n\r\n  // DPI_DrawItems, having type DrawItemPresModel[]\r\n  DrawItems = 'drawItems',\r\n\r\n  // DPI_ClipRect, having type DrawPointsPresModel\r\n  ClipRect = 'clipRect',\r\n\r\n  // DPI_DrawEllipse, having type DrawPointsPresModel\r\n  DrawEllipse = 'drawEllipse',\r\n\r\n  // DPI_DrawFillEllipse, having type DrawPointsPresModel\r\n  DrawFillEllipse = 'drawFillEllipse',\r\n\r\n  // DPI_DrawFillPolygon, having type DrawPointsPresModel\r\n  DrawFillPolygon = 'drawFillPolygon',\r\n\r\n  // DPI_DrawFillRect, having type DrawPointsPresModel\r\n  DrawFillRect = 'drawFillRect',\r\n\r\n  // DPI_DrawPolygon, having type DrawPointsPresModel\r\n  DrawPolygon = 'drawPolygon',\r\n\r\n  // DPI_DrawPolyline, having type DrawPointsPresModel\r\n  DrawPolyline = 'drawPolyline',\r\n\r\n  // DPI_DrawRect, having type DrawPointsPresModel\r\n  DrawRect = 'drawRect',\r\n\r\n  // DPI_DrawFillPath, having type DrawPathPresModel\r\n  DrawFillPath = 'drawFillPath',\r\n\r\n  // DPI_DrawPath, having type DrawPathPresModel\r\n  DrawPath = 'drawPath',\r\n\r\n  // DPI_DrawText, having type DrawTextPresModel\r\n  DrawText = 'drawText',\r\n\r\n  // DPI_DrawImage, having type DrawImagePresModel\r\n  DrawImage = 'drawImage',\r\n\r\n  // DPI_ImageTileInfo, having type ImageTileInfoPresModel\r\n  ImageTileInfo = 'tileInfo',\r\n\r\n  // DPI_ImageTileInfos, having type ImageTileInfoPresModel[]\r\n  ImageTileInfos = 'tileInfos',\r\n\r\n  // DPI_DrawImageTiles, having type DrawImageTilesPresModel\r\n  DrawImageTiles = 'drawImageTiles',\r\n\r\n  // DPI_DrawPen, having type DrawPenPresModel\r\n  DrawPen = 'drawPen',\r\n\r\n  // DPI_DrawSolidBrush, having type DrawSolidBrushPresModel\r\n  DrawSolidBrush = 'drawSolidBrush',\r\n\r\n  // DPI_DrawTextProperties, having type DrawTextPropertiesPresModel\r\n  DrawTextProperties = 'drawTextProps',\r\n\r\n  // DPI_DrawGradientBrush, having type DrawGradientBrushPresModel\r\n  DrawGradientBrush = 'drawGradientBrush',\r\n\r\n  // DPI_DrawTransform, having type DrawTransformPresModel\r\n  DrawTransform = 'transform',\r\n\r\n  // DPI_DrawAntialias, having type DrawAntialiasPresModel\r\n  DrawAntialias = 'drawAntialias',\r\n\r\n  // DPI_ImageDictionary, having type ImageDictionaryPresModel\r\n  ImageDictionary = 'imageDictionary',\r\n\r\n  // DPI_ColorDictionary, having type ColorDictionaryPresModel\r\n  ColorDictionary = 'colorDictionary',\r\n\r\n  // DPI_MarkShape, having type MarkShapePresModel\r\n  MarkShape = 'markShape',\r\n\r\n  // DPI_MarkShapeList, having type MarkShapePresModel[]\r\n  MarkShapeList = 'markShapeList',\r\n\r\n  // DPI_PaneDescriptor, having type PaneDescriptorPresModel\r\n  PaneDescriptor = 'paneDescriptor',\r\n\r\n  // DPI_PDMarks, having type PDMarksPresModel\r\n  PDMarks = 'pdMarks',\r\n\r\n  // DPI_PDMarksMap, having type Dictionary(of PDMarksPresModel)\r\n  PDMarksMap = 'pdMarksMap',\r\n\r\n  // DPI_LabelTextTable, having type LabelTextTable\r\n  LabelTextTable = 'labelTextTable',\r\n\r\n  // DPI_TextTableHelper, having type TextTableHelper\r\n  TextTableHelper = 'textTableHelper',\r\n\r\n  // DPI_GeometryTable, having type GeometryTable\r\n  GeometryTable = 'geometryTable',\r\n\r\n  // DPI_PaneMarks, having type PaneMarksPresModel\r\n  PaneMarks = 'paneMarks',\r\n\r\n  // DPI_PaneMarksList, having type PaneMarksPresModel[]\r\n  PaneMarksList = 'paneMarksList',\r\n\r\n  // DPI_BrushingSelection, having type SelectionPresModel\r\n  BrushingSelection = 'brushing',\r\n\r\n  // DPI_Selection, having type SelectionPresModel\r\n  Selection = 'selection',\r\n\r\n  // DPI_BrushingSelectionList, having type SelectionPresModel[]\r\n  BrushingSelectionList = 'brushingSelectionList',\r\n\r\n  // DPI_SelectionList, having type SelectionPresModel[]\r\n  SelectionList = 'selectionList',\r\n\r\n  // DPI_ShelfSelectionModel, having type ShelfSelectionPresModel\r\n  ShelfSelectionModel = 'shelfSelectionModel',\r\n\r\n  // DPI_ShelfSelectionModels, having type ShelfSelectionPresModel[]\r\n  ShelfSelectionModels = 'shelfSelectionModels',\r\n\r\n  // DPI_ShelfSelectionsModel, having type ShelfSelectionsPresModel\r\n  ShelfSelectionsModel = 'shelfSelectionsModel',\r\n\r\n  // DPI_DimValSelectionModel, having type DimensionValueSelectionPresModel\r\n  DimValSelectionModel = 'dimensionValueSelectionModel',\r\n\r\n  // DPI_DimValSelectionModels, having type DimensionValueSelectionPresModel[]\r\n  DimValSelectionModels = 'dimensionValueSelectionModels',\r\n\r\n  // DPI_HierValSelectionModel, having type HierarchicalValueSelectionPresModel\r\n  HierValSelectionModel = 'hierarchicalValueSelectionModel',\r\n\r\n  // DPI_HierValSelectionModels, having type HierarchicalValueSelectionPresModel[]\r\n  HierValSelectionModels = 'hierarchicalValueSelectionModels',\r\n\r\n  // DPI_QuantRangeSelectionModel, having type QuantativeRangeSelectionPresModel\r\n  QuantRangeSelectionModel = 'quantativeRangeSelectionModel',\r\n\r\n  // DPI_QuantRangeSelectionModels, having type QuantativeRangeSelectionPresModel[]\r\n  QuantRangeSelectionModels = 'quantativeRangeSelectionModels',\r\n\r\n  // DPI_QuantValueSelectionModel, having type QuantativeValueSelectionPresModel\r\n  QuantValueSelectionModel = 'quantativeValueSelectionModel',\r\n\r\n  // DPI_QuantValueSelectionModels, having type QuantativeValueSelectionPresModel[]\r\n  QuantValueSelectionModels = 'quantativeValueSelectionModels',\r\n\r\n  // DPI_LegendSelectionInfo, having type LegendSelectionInfoPresModel\r\n  LegendSelectionInfo = 'legendSelectionInfo',\r\n\r\n  // DPI_NodeReference, having type NodeReferencePresModel\r\n  NodeReference = 'nodeReference',\r\n\r\n  // DPI_PageReference, having type PageReferencePresModel\r\n  PageReference = 'pageReference',\r\n\r\n  // DPI_OrientedNodeReference, having type OrientedNodeReferencePresModel\r\n  OrientedNodeReference = 'orientedNodeReference',\r\n\r\n  // DPI_OrientedNodeReferences, having type OrientedNodeReferencePresModel[]\r\n  OrientedNodeReferences = 'orientedNodeReferences',\r\n\r\n  // DPI_SelectionData, having type SelectionDataPresModel\r\n  SelectionData = 'selectionData',\r\n\r\n  // DPI_HighlightedData, having type HighlightedDataPresModel\r\n  HighlightedData = 'highlightedData',\r\n\r\n  // DPI_Node, having type NodePresModel\r\n  Node = 'node',\r\n\r\n  // DPI_Nodes, having type NodePresModel[]\r\n  Nodes = 'nodes',\r\n\r\n  // DPI_SelectedNodes, having type NodePresModel[]\r\n  SelectedNodes = 'selectedNodes',\r\n\r\n  // DPI_UserAction, having type ActionPresModel\r\n  UserAction = 'userAction',\r\n\r\n  // DPI_UserActions, having type ActionPresModel[]\r\n  UserActions = 'userActions',\r\n\r\n  // DPI_LinkSpec, having type LinkSpecPresModel\r\n  LinkSpec = 'linkSpec',\r\n\r\n  // DPI_ActionSpecificationModel, having type ActionSpecificationPresModel\r\n  ActionSpecificationModel = 'actionSpecification',\r\n\r\n  // DPI_LinkSpecification, having type LinkSpecificationPresModel\r\n  LinkSpecification = 'linkSpecification',\r\n\r\n  // DPI_ScriptDescription, having type ScriptDescriptionPresModel\r\n  ScriptDescription = 'scriptDescription',\r\n\r\n  // DPI_ActionSource, having type ActionSourcePresModel\r\n  ActionSource = 'actionSource',\r\n\r\n  // DPI_FieldExprItem, having type FieldExprItemPresModel\r\n  FieldExprItem = 'fieldExpressionItem',\r\n\r\n  // DPI_FieldExprVector, having type FieldExprItemPresModel[]\r\n  FieldExprVector = 'fieldExpressionVector',\r\n\r\n  // DPI_ActionComboItem, having type ActionComboItemPresModel\r\n  ActionComboItem = 'actionComboItem',\r\n\r\n  // DPI_ActionComboVector, having type ActionComboItemPresModel[]\r\n  ActionComboVector = 'actionComboVector',\r\n\r\n  // DPI_ActionSourceCombo, having type ActionSourceComboPresModel\r\n  ActionSourceCombo = 'actionSourceCombo',\r\n\r\n  // DPI_ActionDestCombo, having type ActionComboPresModel\r\n  ActionDestCombo = 'actionDestCombo',\r\n\r\n  // DPI_ActionFieldList, having type ActionFieldListPresModel\r\n  ActionFieldList = 'actionFieldList',\r\n\r\n  // DPI_EditBrushAction, having type EditBrushActionPresModel\r\n  EditBrushAction = 'editBrushAction',\r\n\r\n  // DPI_UpdateActionSource, having type UpdateActionSourcePresModel\r\n  UpdateActionSource = 'updateActionSource',\r\n\r\n  // DPI_UpdateBrushAction, having type UpdateBrushActionPresModel\r\n  UpdateBrushAction = 'updateBrushAction',\r\n\r\n  // DPI_ActionWarnings, having type ActionWarningsPresModel\r\n  ActionWarnings = 'actionWarnings',\r\n\r\n  // DPI_EditHyperlinkAction, having type EditHyperlinkActionPresModel\r\n  EditHyperlinkAction = 'editHyperlinkAction',\r\n\r\n  // DPI_UpdateHyperlinkAction, having type UpdateHyperlinkActionPresModel\r\n  UpdateHyperlinkAction = 'updateHyperlinkAction',\r\n\r\n  // DPI_EditSheetLinkAction, having type EditSheetLinkActionPresModel\r\n  EditSheetLinkAction = 'editSheetlinkAction',\r\n\r\n  // DPI_UpdateSheetLinkAction, having type UpdateSheetLinkActionPresModel\r\n  UpdateSheetLinkAction = 'updateSheetlinkAction',\r\n\r\n  // DPI_ActionItem, having type ActionItemPresModel\r\n  ActionItem = 'actionItem',\r\n\r\n  // DPI_ActionItemList, having type ActionItemPresModel[]\r\n  ActionItemList = 'actionItemList',\r\n\r\n  // DPI_DataSegment, having type DataSegmentPresModel\r\n  DataSegment = 'dataSegment',\r\n\r\n  // DPI_DataSegments, having type Dictionary(of DataSegmentPresModel)\r\n  DataSegments = 'dataSegments',\r\n\r\n  // DPI_DataDictionary, having type DataDictionaryPresModel\r\n  DataDictionary = 'dataDictionary',\r\n\r\n  // DPI_VizData, having type VizDataPresModel\r\n  VizData = 'vizData',\r\n\r\n  // DPI_VizColumn, having type VizColumnPresModel\r\n  VizColumn = 'vizColumn',\r\n\r\n  // DPI_VizColumns, having type VizColumnPresModel[]\r\n  VizColumns = 'vizColumns',\r\n\r\n  // DPI_VizDataColumn, having type VizDataColumnPresModel\r\n  VizDataColumn = 'vizDataColumn',\r\n\r\n  // DPI_VizDataColumns, having type VizDataColumnPresModel[]\r\n  VizDataColumns = 'vizDataColumns',\r\n\r\n  // DPI_VizPaneColumn, having type VizPaneColumnPresModel\r\n  VizPaneColumn = 'vizPaneColumn',\r\n\r\n  // DPI_VizPaneColumns, having type VizPaneColumnPresModel[]\r\n  VizPaneColumns = 'vizPaneColumns',\r\n\r\n  // DPI_PaneColumns, having type PaneColumnsPresModel\r\n  PaneColumns = 'paneColumns',\r\n\r\n  // DPI_PaneColumnsList, having type PaneColumnsPresModel[]\r\n  PaneColumnsList = 'paneColumnsList',\r\n\r\n  // DPI_PaneColumnsData, having type PaneColumnsDataPresModel\r\n  PaneColumnsData = 'paneColumnsData',\r\n\r\n  // DPI_FilterContext, having type FilterContextPresModel\r\n  FilterContext = 'filterContext',\r\n\r\n  // DPI_UberTipPaneData, having type UberTipPaneDataPresModel\r\n  UberTipPaneData = 'ubertipPaneData',\r\n\r\n  // DPI_UberTipPaneDatas, having type UberTipPaneDataPresModel[]\r\n  UberTipPaneDatas = 'ubertipPaneDatas',\r\n\r\n  // DPI_UberTipData, having type UberTipDataPresModel\r\n  UberTipData = 'ubertipData',\r\n\r\n  // DPI_RefLineTip, having type RefLineTipPresModel\r\n  RefLineTip = 'refLineTip',\r\n\r\n  // DPI_RefLineTips, having type RefLineTipPresModel[]\r\n  RefLineTips = 'refLineTips',\r\n\r\n  // DPI_NumericBin, having type NumericBinPresModel\r\n  NumericBin = 'numericBin',\r\n\r\n  // DPI_NumericBinDialog, having type NumericBinDialogPresModel\r\n  NumericBinDialog = 'numericBinDialog',\r\n\r\n  // DPI_DomainRange, having type DomainRangePresModel\r\n  DomainRange = 'domainRange',\r\n\r\n  // DPI_BinSizeInfo, having type BinSizeInfoPresModel\r\n  BinSizeInfo = 'binSizeInfo',\r\n\r\n  // DPI_DetailedErrorDialog, having type DetailedErrorPresModel\r\n  DetailedErrorDialog = 'detailedErrorDialog',\r\n\r\n  // DPI_DragSourcePosition, having type ShelfDropPositionPresModel\r\n  DragSourcePosition = 'shelfDragSourcePosition',\r\n\r\n  // DPI_DropTargetPosition, having type ShelfDropPositionPresModel\r\n  DropTargetPosition = 'shelfDropTargetPosition',\r\n\r\n  // DPI_ShelfDropPosition, having type ShelfDropPositionPresModel\r\n  ShelfDropPosition = 'shelfDropPosition',\r\n\r\n  // DPI_ShelfDropPositions, having type ShelfDropPositionPresModel[]\r\n  ShelfDropPositions = 'shelfDropPositions',\r\n\r\n  // DPI_ShelfDropModel, having type ShelfDropPresModel\r\n  ShelfDropModel = 'shelfDropModel',\r\n\r\n  // DPI_ShelfDropModels, having type ShelfDropPresModel[]\r\n  ShelfDropModels = 'shelfDropModels',\r\n\r\n  // DPI_Drag, having type DragPresModel\r\n  Drag = 'drag',\r\n\r\n  // DPI_SceneElement, having type SceneElementPresModel\r\n  SceneElement = 'sceneElement',\r\n\r\n  // DPI_SceneElements, having type SceneElementPresModel[]\r\n  SceneElements = 'sceneElements',\r\n\r\n  // DPI_QuickFilterType, having type QuickFilterType\r\n  QuickFilterType = 'quickFilterType',\r\n\r\n  // DPI_CatMode, having type QuickFilterCategoricalMode\r\n  CatMode = 'categoricalMode',\r\n\r\n  // DPI_CatCtrl, having type QuickFilterCategoricalCtrl\r\n  CatCtrl = 'categoricalControl',\r\n\r\n  // DPI_QuantMode, having type QuickFilterQuantitativeMode\r\n  QuantMode = 'quantitativeMode',\r\n\r\n  // DPI_QuantCtrl, having type QuickFilterQuantitativeCtrl\r\n  QuantCtrl = 'quantitativeControl',\r\n\r\n  // DPI_ZoneCommon, having type ZoneCommonPresModel\r\n  ZoneCommon = 'zoneCommon',\r\n\r\n  // DPI_ZoneCommonListItems, having type ZoneCommonPresModel[]\r\n  ZoneCommonListItems = 'zoneCommonListItems',\r\n\r\n  // DPI_Zone, having type ZonePresModel\r\n  Zone = 'zone',\r\n\r\n  // DPI_Zones, having type Dictionary(of ZonePresModel)\r\n  Zones = 'zones',\r\n\r\n  // DPI_ImageZone, having type ImageZonePresModel\r\n  ImageZone = 'imageZone',\r\n\r\n  // DPI_WebZone, having type WebZonePresModel\r\n  WebZone = 'webZone',\r\n\r\n  // DPI_AddInZone, having type AddInZonePresModel\r\n  AddInZone = 'addInZone',\r\n\r\n  // DPI_ButtonZonePresModel, having type ButtonZonePresModel\r\n  ButtonZonePresModel = 'buttonZone',\r\n\r\n  // DPI_ButtonConfigDialog, having type ButtonConfigDialogPresModel\r\n  ButtonConfigDialog = 'buttonConfigDialog',\r\n\r\n  // DPI_ZoneEdgeMoveType, having type ZoneEdgeMove\r\n  ZoneEdgeMoveType = 'zoneEdgeMoveType',\r\n\r\n  // DPI_ZoneSide, having type SideType\r\n  ZoneSide = 'zoneSide',\r\n\r\n  // DPI_SnapPoint, having type SnapPointPresModel\r\n  SnapPoint = 'snapPoint',\r\n\r\n  // DPI_SnapPoints, having type SnapPointPresModel[]\r\n  SnapPoints = 'snapPoints',\r\n\r\n  // DPI_TargetPreviewPair, having type DragDropTargetPreviewPairPresModel\r\n  TargetPreviewPair = 'targetPreviewPair',\r\n\r\n  // DPI_TargetPreviewPairs, having type DragDropTargetPreviewPairPresModel[]\r\n  TargetPreviewPairs = 'targetPreviewPairs',\r\n\r\n  // DPI_ContainerGuide, having type DragDropContainerGuidePresModel\r\n  ContainerGuide = 'containerGuide',\r\n\r\n  // DPI_ContainerGuides, having type DragDropContainerGuidePresModel[]\r\n  ContainerGuides = 'containerGuides',\r\n\r\n  // DPI_ZoneBorder, having type DragDropZoneBorderPresModel\r\n  ZoneBorder = 'zoneBorder',\r\n\r\n  // DPI_ZoneBorders, having type DragDropZoneBorderPresModel[]\r\n  ZoneBorders = 'zoneBorders',\r\n\r\n  // DPI_DashboardDragDrop, having type DashboardDragDropPresModel\r\n  DashboardDragDrop = 'zoneDragDrop',\r\n\r\n  // DPI_DragZoneResize, having type DragZoneResizePresModel\r\n  DragZoneResize = 'zoneResize',\r\n\r\n  // DPI_DashboardText, having type TextRegionPresModel\r\n  DashboardText = 'dashboardText',\r\n\r\n  // DPI_DashboardTitle, having type TextRegionPresModel\r\n  DashboardTitle = 'dashboardTitle',\r\n\r\n  // DPI_QuickFilterTitle, having type TextRegionPresModel\r\n  QuickFilterTitle = 'quickFilterTitle',\r\n\r\n  // DPI_VisualCaption, having type TextRegionPresModel\r\n  VisualCaption = 'visualCaption',\r\n\r\n  // DPI_VisualTitle, having type TextRegionPresModel\r\n  VisualTitle = 'visualTitle',\r\n\r\n  // DPI_ZoneTitleRegion, having type TextRegionPresModel\r\n  ZoneTitleRegion = 'zoneTitle',\r\n\r\n  // DPI_ForecastOptions, having type ForecastPresModel\r\n  ForecastOptions = 'forecastOptions',\r\n\r\n  // DPI_ForecastDescription, having type ForecastDescribePresModel\r\n  ForecastDescription = 'forecastDescription',\r\n\r\n  // DPI_WorkgroupPublishObject, having type WorkgroupPublishObjectPresModel\r\n  WorkgroupPublishObject = 'publishDataSource',\r\n\r\n  // DPI_PublishPermissionsSummary, having type PublishPermissionsSummaryPresModel\r\n  PublishPermissionsSummary = 'publishPermissionsSummary',\r\n\r\n  // DPI_CheckNameResults, having type CheckNameResultsPresModel\r\n  CheckNameResults = 'checkNameResults',\r\n\r\n  // DPI_ValidatePublishViewsResult, having type ValidatePublishViewsResultPresModel\r\n  ValidatePublishViewsResult = 'validatePublishViewsResult',\r\n\r\n  // DPI_PublishAuthenticationSettings, having type PublishAuthenticationSettingsPresModel\r\n  PublishAuthenticationSettings = 'publishAuthenticationSettings',\r\n\r\n  // DPI_ManageDatasources, having type ManageDatasourcesPresModel\r\n  ManageDatasources = 'manageDatasources',\r\n\r\n  // DPI_CredentialsAuthSettings, having type CredentialsAuthSettingsPresModel\r\n  CredentialsAuthSettings = 'credentialsAuthSettings',\r\n\r\n  // DPI_ConnectionCredentialsAuthSettings, having type ConnectionCredentialsAuthSettingsPresModel\r\n  ConnectionCredentialsAuthSettings = 'connectionCredentialsAuthSettings',\r\n\r\n  // DPI_ConnectionCredentialsAuthSettingsList, having type ConnectionCredentialsAuthSettingsPresModel[]\r\n  ConnectionCredentialsAuthSettingsList = 'connectionCredentialsAuthSettingsList',\r\n\r\n  // DPI_PublishDatasourceFromWorkbookInfo, having type PublishDatasourceFromWorkbookInfoPresModel\r\n  PublishDatasourceFromWorkbookInfo = 'publishDatasourceFromWorkbookInfo',\r\n\r\n  // DPI_PublishDatasourcesFromWorkbookInfo, having type PublishDatasourceFromWorkbookInfoPresModel[]\r\n  PublishDatasourcesFromWorkbookInfo = 'publishDatasourcesFromWorkbookInfo',\r\n\r\n  // DPI_PublishSheet, having type PublishSheetPresModel\r\n  PublishSheet = 'publishSheet',\r\n\r\n  // DPI_PublishSheets, having type PublishSheetPresModel[]\r\n  PublishSheets = 'publishSheets',\r\n\r\n  // DPI_PublishObjectViews, having type PublishObjectViewsPresModel\r\n  PublishObjectViews = 'publishObjectViews',\r\n\r\n  // DPI_PublishObjectPublishSheetResults, having type PublishObjectPublishSheetResultsPresModel\r\n  PublishObjectPublishSheetResults = 'publishObjectPublishSheetResults',\r\n\r\n  // DPI_RefreshExtractSchedulingSettings, having type RefreshExtractSchedulingSettingsPresModel\r\n  RefreshExtractSchedulingSettings = 'refreshExtractSchedulingSettings',\r\n\r\n  // DPI_SetRefreshExtractScheduleResult, having type SetRefreshExtractScheduleResultPresModel\r\n  SetRefreshExtractScheduleResult = 'setRefreshExtractScheduleResult',\r\n\r\n  // DPI_CheckPublishObjectNameWarningsResults, having type CheckPublishObjectNameWarningsResultsPresModel\r\n  CheckPublishObjectNameWarningsResults = 'checkPublishObjectNameWarningsResults',\r\n\r\n  // DPI_PublishDatasourceOnWorkbookPublishResults, having type PublishDatasourceOnWorkbookPublishResultsPresModel\r\n  PublishDatasourceOnWorkbookPublishResults = 'publishDatasourceOnWorkbookPublishResult',\r\n\r\n  // DPI_PublishDataSourceResult, having type PublishDataSourceResultPresModel\r\n  PublishDataSourceResult = 'publishDataSourceResult',\r\n\r\n  // DPI_PublishWarningMessage, having type PublishWarningMessagePresModel\r\n  PublishWarningMessage = 'publishWarningMessage',\r\n\r\n  // DPI_MustDowngradeToPublishWarningMessagePresModel, having type PublishWarningMessagePresModel\r\n  MustDowngradeToPublishWarningMessagePresModel = 'mustDowngradeToPublishWarningMessagePresModel',\r\n\r\n  // DPI_PublishSelectedAttributes, having type PublishSelectedAttributesPresModel\r\n  PublishSelectedAttributes = 'publishSelectedAttributes',\r\n\r\n  // DPI_AutosaveFile, having type AutosaveFilePresModel\r\n  AutosaveFile = 'autosaveFile',\r\n\r\n  // DPI_AutosaveFiles, having type AutosaveFilePresModel[]\r\n  AutosaveFiles = 'autosaveFiles',\r\n\r\n  // DPI_FunctionGroup, having type FunctionGroup\r\n  FunctionGroup = 'funcGrp',\r\n\r\n  // DPI_FunctionGroups, having type FunctionGroup[]\r\n  FunctionGroups = 'funcGrps',\r\n\r\n  // DPI_FunctionArgType, having type FunctionArgType\r\n  FunctionArgType = 'funcArgType',\r\n\r\n  // DPI_FunctionArgTypes, having type FunctionArgType[]\r\n  FunctionArgTypes = 'funcArgTypes',\r\n\r\n  // DPI_CalculationStyle, having type CalcStyle\r\n  CalculationStyle = 'calculationStyle',\r\n\r\n  // DPI_Calculation, having type CalculationPresModel\r\n  Calculation = 'calculation',\r\n\r\n  // DPI_TypeInPill, having type CalculationPresModel\r\n  TypeInPill = 'typeInPill',\r\n\r\n  // DPI_CalcErrorInfo, having type CalcErrorInfoPresModel\r\n  CalcErrorInfo = 'errorInfo',\r\n\r\n  // DPI_CalcErrorInfos, having type CalcErrorInfoPresModel[]\r\n  CalcErrorInfos = 'errorInfoList',\r\n\r\n  // DPI_CalcualtionValidation, having type CalculationValidationPresModel\r\n  CalcualtionValidation = 'calculationValidation',\r\n\r\n  // DPI_ExpressionFunction, having type ExpressionFunctionPresModel\r\n  ExpressionFunction = 'expressionFunc',\r\n\r\n  // DPI_ExpressionFunctions, having type ExpressionFunctionPresModel[]\r\n  ExpressionFunctions = 'expressionFuncList',\r\n\r\n  // DPI_ExpressionFunctionsPM, having type ExpressionFunctionsPresModel\r\n  ExpressionFunctionsPM = 'expressionFuncPm',\r\n\r\n  // DPI_StyleToken, having type StyleTokenPresModel\r\n  StyleToken = 'styleToken',\r\n\r\n  // DPI_StyleTokens, having type StyleTokenPresModel[]\r\n  StyleTokens = 'styleTokenList',\r\n\r\n  // DPI_CalcEditorTextSelection, having type CalcEditorTextSelectionPresModel\r\n  CalcEditorTextSelection = 'calcEditorTextSelection',\r\n\r\n  // DPI_AutoCompleteItemType, having type AutoCompleteItemType\r\n  AutoCompleteItemType = 'autocompleteType',\r\n\r\n  // DPI_AutoCompleteItem, having type AutoCompleteItemPresModel\r\n  AutoCompleteItem = 'autocompleteItem',\r\n\r\n  // DPI_AutoCompleteItems, having type AutoCompleteItemPresModel[]\r\n  AutoCompleteItems = 'autocompleteItemList',\r\n\r\n  // DPI_CalculationAutoCompleteContextMenu, having type CalculationAutoCompleteContextMenuPresModel\r\n  CalculationAutoCompleteContextMenu = 'calculationAutocompleteContextMenu',\r\n\r\n  // DPI_CalcApplyResult, having type CalcApplyResult\r\n  CalcApplyResult = 'calculationApplyResult',\r\n\r\n  // DPI_RampBorderStyledBox, having type StyledBoxPresModel\r\n  RampBorderStyledBox = 'rampBorderStyledBox',\r\n\r\n  // DPI_StyledBox, having type StyledBoxPresModel\r\n  StyledBox = 'styledBox',\r\n\r\n  // DPI_GlobalStyledBox, having type StyledBoxPresModel\r\n  GlobalStyledBox = 'globalStyledBox',\r\n\r\n  // DPI_StyleContext, having type StyleContextPresModel\r\n  StyleContext = 'styleContext',\r\n\r\n  // DPI_CurrentTextStyle, having type TextStylePresModel\r\n  CurrentTextStyle = 'currentTextStyle',\r\n\r\n  // DPI_LabelTextStyle, having type TextStylePresModel\r\n  LabelTextStyle = 'labelTextStyle',\r\n\r\n  // DPI_OriginalTextStyle, having type TextStylePresModel\r\n  OriginalTextStyle = 'originalTextStyle',\r\n\r\n  // DPI_SelectedTextStyleModel, having type TextStylePresModel\r\n  SelectedTextStyleModel = 'selectedTextStyleModel',\r\n\r\n  // DPI_SwatchTextStyleModel, having type TextStylePresModel\r\n  SwatchTextStyleModel = 'swatchTextStyle',\r\n\r\n  // DPI_TextStyleModel, having type TextStylePresModel\r\n  TextStyleModel = 'textStyle',\r\n\r\n  // DPI_TitleStyleModel, having type TextStylePresModel\r\n  TitleStyleModel = 'titleStyleModel',\r\n\r\n  // DPI_PropertyBag, having type PropertyBagPresModel\r\n  PropertyBag = 'propBagWrapper',\r\n\r\n  // DPI_PresModelMap, having type Dictionary(of PropertyBagPresModel)\r\n  PresModelMap = 'presModelMap',\r\n\r\n  // DPI_PresentationLayerNotifications, having type PresModelMapPresModel\r\n  PresentationLayerNotifications = 'presentationLayerNotifications',\r\n\r\n  // DPI_SecondaryInfo, having type PresModelMapPresModel\r\n  SecondaryInfo = 'secondaryInfo',\r\n\r\n  // DPI_ClientDashboardUIMetric, having type ClientDashboardUIMetricPresModel\r\n  ClientDashboardUIMetric = 'clientDashboardUiMetric',\r\n\r\n  // DPI_ClientDashboardUIMetrics, having type ClientDashboardUIMetricPresModel[]\r\n  ClientDashboardUIMetrics = 'clientDashboardUiMetrics',\r\n\r\n  // DPI_ClientDashboardUIMetricContainer, having type ClientDashboardUIMetricContainerPresModel\r\n  ClientDashboardUIMetricContainer = 'clientDashboardUiMetricContainer',\r\n\r\n  // DPI_ExtSvcConfig, having type ExtSvcConfigPresModel\r\n  ExtSvcConfig = 'extSvcConfig',\r\n\r\n  // DPI_StoryboardSheetItem, having type StoryboardSheetItemPresModel\r\n  StoryboardSheetItem = 'storyboardSheetItem',\r\n\r\n  // DPI_StoryboardSheetItems, having type StoryboardSheetItemPresModel[]\r\n  StoryboardSheetItems = 'storyboardSheetItems',\r\n\r\n  // DPI_StoryboardSheetList, having type StoryboardSheetListPresModel\r\n  StoryboardSheetList = 'storyboardSheetList',\r\n\r\n  // DPI_FitToStoryBoardOptionItem, having type FitToStoryBoardOptionItemPresModel\r\n  FitToStoryBoardOptionItem = 'fitToStoryboardOptionItem',\r\n\r\n  // DPI_FitToStoryBoardOptionItems, having type FitToStoryBoardOptionItemPresModel[]\r\n  FitToStoryBoardOptionItems = 'fitToStoryboardOptionItems',\r\n\r\n  // DPI_FitToStoryBoardOptionList, having type FitToStoryBoardOptionListPresModel\r\n  FitToStoryBoardOptionList = 'fitToStoryboardOptionList',\r\n\r\n  // DPI_StoryPointNavItem, having type StoryPointNavItemPresModel\r\n  StoryPointNavItem = 'storypointNavItem',\r\n\r\n  // DPI_StoryPointNavItems, having type StoryPointNavItemPresModel[]\r\n  StoryPointNavItems = 'storypointNavItems',\r\n\r\n  // DPI_FlipboardNav, having type FlipboardNavPresModel\r\n  FlipboardNav = 'flipboardNav',\r\n\r\n  // DPI_ScrollBarStyle, having type ScrollBarStylePresModel\r\n  ScrollBarStyle = 'scrollBarStyle',\r\n\r\n  // DPI_DashboardZoneLayoutPane, having type DashboardZoneLayoutPanePresModel\r\n  DashboardZoneLayoutPane = 'dashboardZoneLayoutPane',\r\n\r\n  // DPI_SelectedStoryPointStyle, having type StoryPointCaptionStylePresModel\r\n  SelectedStoryPointStyle = 'selectedStoryPointStyle',\r\n\r\n  // DPI_UnselectedStoryPointStyle, having type StoryPointCaptionStylePresModel\r\n  UnselectedStoryPointStyle = 'unselectedStoryPointStyle',\r\n\r\n  // DPI_FlipboardNavStyle, having type FlipboardNavStylePresModel\r\n  FlipboardNavStyle = 'flipboardNavStyle',\r\n\r\n  // DPI_StoryPoint, having type StoryPointPresModel\r\n  StoryPoint = 'storyPoint',\r\n\r\n  // DPI_StoryPoints, having type Dictionary(of StoryPointPresModel)\r\n  StoryPoints = 'storyPoints',\r\n\r\n  // DPI_Flipboard, having type FlipboardPresModel\r\n  Flipboard = 'flipboard',\r\n\r\n  // DPI_StoryPair, having type StoryPairPresModel\r\n  StoryPair = 'storyPair',\r\n\r\n  // DPI_StoryPairs, having type StoryPairPresModel[]\r\n  StoryPairs = 'storyPairs',\r\n\r\n  // DPI_StoryboardPM, having type StoryboardPresModel\r\n  StoryboardPM = 'storyboardPm',\r\n\r\n  // DPI_HiDpiIconDictionary, having type ImageCollectionPresModel\r\n  HiDpiIconDictionary = 'hiDpiIconDictionary',\r\n\r\n  // DPI_IconDictionary, having type ImageCollectionPresModel\r\n  IconDictionary = 'iconDictionary',\r\n\r\n  // DPI_IconResourceDictionary, having type ImageResourceCollectionPresModel\r\n  IconResourceDictionary = 'iconResDictionary',\r\n\r\n  // DPI_DataPreviewWindowMessage, having type DataPreviewWindowMessagePresModel\r\n  DataPreviewWindowMessage = 'dataPreviewWindowMessage',\r\n\r\n  // DPI_DataSourceData, having type DataSourceDataPresModel\r\n  DataSourceData = 'dataSrcData',\r\n\r\n  // DPI_DataSourceSort, having type DataSourceSortPresModel\r\n  DataSourceSort = 'dataSrcSort',\r\n\r\n  // DPI_ColumnInfo, having type DSColumnInfoPresModel\r\n  ColumnInfo = 'columnInfo',\r\n\r\n  // DPI_ColumnInfos, having type DSColumnInfoPresModel[]\r\n  ColumnInfos = 'columnInfos',\r\n\r\n  // DPI_DataFormatter, having type DVFormatter\r\n  DataFormatter = 'dataFormatter',\r\n\r\n  // DPI_JoinDescription, having type JoinDescriptionPresModel\r\n  JoinDescription = 'joinDescription',\r\n\r\n  // DPI_JoinDescriptions, having type Dictionary(of JoinDescriptionPresModel)\r\n  JoinDescriptions = 'joinDescriptions',\r\n\r\n  // DPI_FileTableInfo, having type FileTableInfoPresModel\r\n  FileTableInfo = 'fileTableInfo',\r\n\r\n  // DPI_FieldMapping, having type FieldMappingPresModel\r\n  FieldMapping = 'fieldMapping',\r\n\r\n  // DPI_FieldMappingData, having type FieldMappingDataPresModel\r\n  FieldMappingData = 'fieldMappingData',\r\n\r\n  // DPI_FieldMappingDataVector, having type FieldMappingDataPresModel[]\r\n  FieldMappingDataVector = 'fieldMappingDataVector',\r\n\r\n  // DPI_FrameFinder, having type FrameFinderPresModel\r\n  FrameFinder = 'frameFinder',\r\n\r\n  // DPI_SheetLinkFieldMapping, having type SheetLinkFieldMappingPresModel\r\n  SheetLinkFieldMapping = 'sheetLinkFieldMapping',\r\n\r\n  // DPI_UnionInfo, having type UnionInfoPresModel\r\n  UnionInfo = 'unionInfo',\r\n\r\n  // DPI_UnionTableInfo, having type UnionTableInfoPresMode\r\n  UnionTableInfo = 'unionTableInfo',\r\n\r\n  // DPI_UnionTableInfos, having type UnionTableInfoPresModel[]\r\n  UnionTableInfos = 'unionTableInfos',\r\n\r\n  // DPI_ConnectionPBUnionInfo, having type PBUnionInfoPresModel\r\n  ConnectionPBUnionInfo = 'connectionPbunionInfo',\r\n\r\n  // DPI_ConnectionPBUnionInfos, having type PBUnionInfoPresModel[]\r\n  ConnectionPBUnionInfos = 'connectionPbunionInfos',\r\n\r\n  // DPI_JoinClause, having type JoinClausePresModel\r\n  JoinClause = 'joinClause',\r\n\r\n  // DPI_JoinClauses, having type JoinClausePresModel[]\r\n  JoinClauses = 'joinClauses',\r\n\r\n  // DPI_JoinValidationResult, having type JoinValidationResultPresModel\r\n  JoinValidationResult = 'joinValidationResult',\r\n\r\n  // DPI_JoinTableInfo, having type JoinTableInfoPresModel\r\n  JoinTableInfo = 'joinTableInfo',\r\n\r\n  // DPI_ParameterInfo, having type JoinTableInfoPresModel\r\n  ParameterInfo = 'parameterInfo',\r\n\r\n  // DPI_JoinTableInfos, having type JoinTableInfoPresModel[]\r\n  JoinTableInfos = 'joinTableInfos',\r\n\r\n  // DPI_JoinOnCalcInfo, having type JoinOnCalcInfoPresModel\r\n  JoinOnCalcInfo = 'joinOnCalcInfo',\r\n\r\n  // DPI_ConnectionSummary, having type ConnectionSummaryPresModel\r\n  ConnectionSummary = 'connectionSummary',\r\n\r\n  // DPI_ConnectionSummaries, having type ConnectionSummaryPresModel[]\r\n  ConnectionSummaries = 'connectionSummaries',\r\n\r\n  // DPI_TopLevelConnectionDescription, having type TopLevelConnectionDescriptionPresModel\r\n  TopLevelConnectionDescription = 'topLevelConnectionDescription',\r\n\r\n  // DPI_DataConnectionTableViewMessages, having type DataConnectionTableViewMessagesPresModel\r\n  DataConnectionTableViewMessages = 'dataConnectionTableViewMessages',\r\n\r\n  // DPI_TextTransformScript, having type TextTransformScriptPresModel\r\n  TextTransformScript = 'textTransformScript',\r\n\r\n  // DPI_CalendarDateOptions, having type CalendarDateOptionsPresModel\r\n  CalendarDateOptions = 'calendarDateOptions',\r\n\r\n  // DPI_GoToWorksheetTooltipPresModel, having type GoToWorksheetTooltipPresModel\r\n  GoToWorksheetTooltipPresModel = 'goToWorksheetTooltipPresModel',\r\n\r\n  // DPI_TableCleaningPresModel, having type TableCleaningPresModel\r\n  TableCleaningPresModel = 'tableCleaningPresModel',\r\n\r\n  // DPI_PivotPresModel, having type PivotPresModel\r\n  PivotPresModel = 'pivotPresModel',\r\n\r\n  // DPI_PivotTreeItemPresModel, having type PivotTreeItemPresModel\r\n  PivotTreeItemPresModel = 'pivotTreeItemPresModel',\r\n\r\n  // DPI_PivotTreeItems, having type PivotTreeItemPresModel[]\r\n  PivotTreeItems = 'pivotTreeItemsPresModel',\r\n\r\n  // DPI_PivotDisplay, having type PivotDisplayPresModel\r\n  PivotDisplay = 'pivotDisplay',\r\n\r\n  // DPI_PivotTag, having type NameColumnsPairPresModel\r\n  PivotTag = 'pivotTag',\r\n\r\n  // DPI_PivotGroups, having type NameColumnsPairPresModel[]\r\n  PivotGroups = 'pivotGroups',\r\n\r\n  // DPI_DataSourceDropdown, having type DataSourceDropdownPresModel\r\n  DataSourceDropdown = 'dataSourceDropdown',\r\n\r\n  // DPI_ConnectionDropdown, having type ConnectionDropdownPresModel\r\n  ConnectionDropdown = 'connectionDropdown',\r\n\r\n  // DPI_ActivityEvent, having type ActivityEventPresModel\r\n  ActivityEvent = 'activityEvent',\r\n\r\n  // DPI_UIAutomation, having type UIAutomationPresModel\r\n  UIAutomation = 'uiAutomation',\r\n\r\n  // DPI_UIAutomationIndex, having type UIAutomationIndexPresModel\r\n  UIAutomationIndex = 'uiAutomationIndex',\r\n\r\n  // DPI_UIAutomationIndexList, having type UIAutomationIndexPresModel[]\r\n  UIAutomationIndexList = 'uiAutomationIndexList',\r\n\r\n  // DPI_UIAutomationComponentInfo, having type UIAutomationComponentInfoPresModel\r\n  UIAutomationComponentInfo = 'uiAutomationComponentInfo',\r\n\r\n  // DPI_UIAutomationComponentInfoList, having type UIAutomationComponentInfoPresModel[]\r\n  UIAutomationComponentInfoList = 'uiAutomationComponentInfoList',\r\n\r\n  // DPI_Geometry, having type GeometryPresModel\r\n  Geometry = 'geometry',\r\n\r\n  // DPI_MultiPoint, having type MultiPointPresModel\r\n  MultiPoint = 'multiPoint',\r\n\r\n  // DPI_MultiLine, having type MultiLinePresModel\r\n  MultiLine = 'multiLine',\r\n\r\n  // DPI_MultiPolygon, having type MultiPolygonPresModel\r\n  MultiPolygon = 'multiPolygon',\r\n\r\n  // DPI_Polygon, having type PolygonPresModel\r\n  Polygon = 'polygon',\r\n\r\n  // DPI_PolygonList, having type PolygonPresModel[]\r\n  PolygonList = 'polygonList',\r\n\r\n  // DPI_Line, having type LinePresModel\r\n  Line = 'line',\r\n\r\n  // DPI_LineList, having type LinePresModel[]\r\n  LineList = 'lineList',\r\n\r\n  // DPI_TabbedAuthentication, having type TabbedAuthenticationPresModel\r\n  TabbedAuthentication = 'tabbedAuthentication',\r\n\r\n  // DPI_TabbedAuthenticationTabInfo, having type TabbedAuthenticationTabInfoPresModel\r\n  TabbedAuthenticationTabInfo = 'tabbedAuthenticationTabInfo',\r\n\r\n  // DPI_TabbedAuthenticationTabInfos, having type TabbedAuthenticationTabInfoPresModel[]\r\n  TabbedAuthenticationTabInfos = 'tabbedAuthenticationTabInfos',\r\n\r\n  // DPI_GeographicSearchCandidate, having type GeographicSearchCandidatePresModel\r\n  GeographicSearchCandidate = 'geographicSearchCandidate',\r\n\r\n  // DPI_GeographicSearchCandidateList, having type GeographicSearchCandidatePresModel[]\r\n  GeographicSearchCandidateList = 'geographicSearchCandidateList',\r\n\r\n  // DPI_GeographicSearchResults, having type GeographicSearchPresModel\r\n  GeographicSearchResults = 'geographicSearchResults',\r\n\r\n  // DPI_ParamInfo, having type ParameterInfoPresModel\r\n  ParamInfo = 'paramInfo',\r\n\r\n  // DPI_ParamInfos, having type ParameterInfoPresModel[]\r\n  ParamInfos = 'paramInfos',\r\n\r\n  // DPI_ParamNamespaceInfo, having type ParameterNamespaceInfoInfoPresModel\r\n  ParamNamespaceInfo = 'paramNamespaceInfo',\r\n\r\n  // DPI_ParamNamespaceInfos, having type ParameterNamespaceInfoPresModel[]\r\n  ParamNamespaceInfos = 'paramNamespaceInfos',\r\n\r\n  // DPI_ParamRegistryInfo, having type ParameterRegistryInfoPresModel\r\n  ParamRegistryInfo = 'paramRegistryInfo',\r\n\r\n  // DPI_DataSourceProperties, having type DataSourcePropertiesPresModel\r\n  DataSourceProperties = 'connectionProperties',\r\n\r\n  // DPI_ConnectionTypePresModel, having type ConnectionTypePresModel\r\n  ConnectionTypePresModel = 'connectionTypePresModel',\r\n\r\n  // DPI_ConnectionTypes, having type ConnectionTypePresModel[]\r\n  ConnectionTypes = 'connectionTypes',\r\n\r\n  // DPI_ConnectionTypeGroupPresModel, having type ConnectionTypeGroupPresModel\r\n  ConnectionTypeGroupPresModel = 'connectionTypeGroupPresModel',\r\n\r\n  // DPI_SavedDataSourcePresModel, having type SavedDataSourcePresModel\r\n  SavedDataSourcePresModel = 'savedDatasourcePresModel',\r\n\r\n  // DPI_SavedDataSources, having type SavedDataSourcePresModel[]\r\n  SavedDataSources = 'savedDatasources',\r\n\r\n  // DPI_SavedDataSourcesPresModel, having type SavedDataSourcesPresModel\r\n  SavedDataSourcesPresModel = 'savedDatasourcesPresModel',\r\n\r\n  // DPI_OpenPaneItemPresModel, having type OpenPaneItemPresModel\r\n  OpenPaneItemPresModel = 'openPaneItemPresModel',\r\n\r\n  // DPI_OpenPaneItems, having type OpenPaneItemPresModel[]\r\n  OpenPaneItems = 'openPaneItems',\r\n\r\n  // DPI_OpenPaneItemsPresModel, having type OpenPaneItemsPresModel\r\n  OpenPaneItemsPresModel = 'openPaneItemsPresModel',\r\n\r\n  // DPI_VariableValue, having type VariableValuePresModel\r\n  VariableValue = 'variableValue',\r\n\r\n  // DPI_VariableValues, having type VariableValuePresModel[]\r\n  VariableValues = 'variableValues',\r\n\r\n  // DPI_ServerVariableValue, having type ServerVariableValuePresModel\r\n  ServerVariableValue = 'serverVariableValue',\r\n\r\n  // DPI_EditableVariableValue, having type EditableVariableValuePresModel\r\n  EditableVariableValue = 'editableVariableValue',\r\n\r\n  // DPI_ServerVariableMetadata, having type ServerVariableMetadataPresModel\r\n  ServerVariableMetadata = 'serverVariableMetadata',\r\n\r\n  // DPI_PromptVariable, having type PromptVariablePresModel\r\n  PromptVariable = 'promptVariable',\r\n\r\n  // DPI_PromptVariables, having type PromptVariablePresModel[]\r\n  PromptVariables = 'promptVariables',\r\n\r\n  // DPI_VariablePromptDialog, having type VariablePromptDialogPresModel\r\n  VariablePromptDialog = 'variablePromptDialog',\r\n\r\n  // DPI_VariableValueOperation, having type VariableValueOperationPresModel\r\n  VariableValueOperation = 'variableValueOperation',\r\n\r\n  // DPI_VariableValueOperations, having type VariableValueOperationPresModel[]\r\n  VariableValueOperations = 'variableValueOperations',\r\n\r\n  // DPI_TableOptionsPresModel, having type TableOptionsPresModel\r\n  TableOptionsPresModel = 'tableOptionsPresModel',\r\n\r\n  // DPI_ClientInfoPresModel, having type ClientInfoPresModel\r\n  ClientInfoPresModel = 'clientInfoPresModel',\r\n\r\n  // DPI_TableauFileInfoPresModel, having type TableauFileInfoPresModel\r\n  TableauFileInfoPresModel = 'tableauFileInfoPresModel',\r\n\r\n  // DPI_DebuggingInfoPresModel, having type DebuggingInfoPresModel\r\n  DebuggingInfoPresModel = 'debuggingInfoPresModel',\r\n\r\n  // DPI_RunningThreadInfoPresModel, having type RunningThreadInfoPresModel\r\n  RunningThreadInfoPresModel = 'runningThreadInfoPresModel',\r\n\r\n  // DPI_AboutDialogInfoPresModel, having type AboutDialogInfoPresModel\r\n  AboutDialogInfoPresModel = 'aboutDialogInfoPresModel',\r\n\r\n  // DPI_HybridUIShowcasePresModel, having type HybridUIShowcasePresModel\r\n  HybridUIShowcasePresModel = 'hybridUiShowcasePresModel',\r\n\r\n  // DPI_MenuConfiguration, having type MenuConfigurationPresModel\r\n  MenuConfiguration = 'menuConfiguration',\r\n\r\n  // DPI_MenuItem, having type MenuItemPresModel\r\n  MenuItem = 'menuItem',\r\n\r\n  // DPI_MenuItemModels, having type MenuItemPresModel[]\r\n  MenuItemModels = 'menuItemModels',\r\n\r\n  // DPI_DefaultTextFormat, having type DefaultTextFormatPresModel\r\n  DefaultTextFormat = 'defaultTextFormat',\r\n\r\n  // DPI_MapBoxServerInfoPresModel, having type MapBoxServerInfoPresModel\r\n  MapBoxServerInfoPresModel = 'mapboxServerInfoPresModel',\r\n\r\n  // DPI_WMSServerInfoPresModel, having type WMSServerInfoPresModel\r\n  WMSServerInfoPresModel = 'wmsServerInfoPresModel',\r\n\r\n  // DPI_MapSourceConflictPresModel, having type MapSourceConflictPresModel\r\n  MapSourceConflictPresModel = 'mapSourceConflictPresModel',\r\n\r\n  // DPI_EnumeratedSetDialogPresModel, having type EnumeratedSetDialogPresModel\r\n  EnumeratedSetDialogPresModel = 'enumeratedSetDialogPresModel',\r\n\r\n  // DPI_EditAliasesDialog, having type EditAliasesDialogPresModel\r\n  EditAliasesDialog = 'editAliasesDialogPresModel',\r\n\r\n  // DPI_AliasesPresModel, having type AliasesPresModel\r\n  AliasesPresModel = 'aliasesPresModel',\r\n\r\n  // DPI_ClearAliasesPresModel, having type AliasesPresModel\r\n  ClearAliasesPresModel = 'clearAliasesPresModel',\r\n\r\n  // DPI_NewAliasesPresModel, having type NewAliasesPresModel\r\n  NewAliasesPresModel = 'newAliasesPresModel',\r\n\r\n  // DPI_AliasPresModel, having type AliasPresModel\r\n  AliasPresModel = 'aliasPresModel',\r\n\r\n  // DPI_AliasItem, having type AliasItemPresModel\r\n  AliasItem = 'aliasItem',\r\n\r\n  // DPI_DuplicateAliasItem, having type AliasItemPresModel\r\n  DuplicateAliasItem = 'duplicateAliasItem',\r\n\r\n  // DPI_AliasList, having type AliasItemPresModel[]\r\n  AliasList = 'aliasList',\r\n\r\n  // DPI_AliasResultItem, having type AliasResultItemPresModel\r\n  AliasResultItem = 'aliasResultItem',\r\n\r\n  // DPI_AliasResultList, having type AliasResultItemPresModel[]\r\n  AliasResultList = 'aliasResultList',\r\n\r\n  // DPI_AliasResults, having type AliasResultsPresModel\r\n  AliasResults = 'aliasResults',\r\n\r\n  // DPI_EditSetDialogPresModel, having type EditSetDialogPresModel\r\n  EditSetDialogPresModel = 'editSetDialogPresModel',\r\n\r\n  // DPI_ConfirmationPresModel, having type ConfirmationPresModel\r\n  ConfirmationPresModel = 'confirmationPresModel',\r\n\r\n  // DPI_NotificationPresModel, having type NotificationPresModel\r\n  NotificationPresModel = 'notificationPresModel',\r\n\r\n  // DPI_RetargetDataSourceDialogPresModel, having type RetargetDataSourceDialogPresModel\r\n  RetargetDataSourceDialogPresModel = 'retargetDatasourceDialogPresModel',\r\n\r\n  // DPI_SharedFilterPresModel, having type SharedFilterPresModel\r\n  SharedFilterPresModel = 'sharedFilterPresModel',\r\n\r\n  // DPI_SharedFilterWorksheetInfo, having type SharedFilterWorksheetInfoPresModel\r\n  SharedFilterWorksheetInfo = 'sharedFilterWorksheetInfo',\r\n\r\n  // DPI_SharedFilterWorksheetInfoList, having type SharedFilterWorksheetInfoPresModel[]\r\n  SharedFilterWorksheetInfoList = 'sharedFilterWorksheetInfoList',\r\n\r\n  // DPI_FieldPickerTreePresModel, having type FieldPickerTreePresModel\r\n  FieldPickerTreePresModel = 'fieldPickerTreePresModel',\r\n\r\n  // DPI_FieldPickerTreePresModelSource, having type FieldPickerTreePresModel\r\n  FieldPickerTreePresModelSource = 'fieldPickerTreePresModelSource',\r\n\r\n  // DPI_FieldPickerTreePresModelTarget, having type FieldPickerTreePresModel\r\n  FieldPickerTreePresModelTarget = 'fieldPickerTreePresModelTarget',\r\n\r\n  // DPI_ErrorInfo, having type ErrorInfoPresModel\r\n  ErrorInfo = 'errorInfoPresModel',\r\n\r\n  // DPI_CustomSplitPresModel, having type CustomSplitPresModel\r\n  CustomSplitPresModel = 'customSplitPresModel',\r\n\r\n  // DPI_PageSetup, having type PageSetupPresModel\r\n  PageSetup = 'pageSetup',\r\n\r\n  // DPI_ServerConnectStatus, having type ServerConnectionStatus\r\n  ServerConnectStatus = 'serverConnectionStatus',\r\n\r\n  // DPI_GetFilterItemsResponse, having type GetFilterItemsResponsePresModel\r\n  GetFilterItemsResponse = 'getFilterItemsResponse',\r\n\r\n  // DPI_FilterSearchResponse, having type FilterSearchResponsePresModel\r\n  FilterSearchResponse = 'filterSearchResponse',\r\n\r\n  // DPI_FilterSearchWithIndexResponse, having type FilterSearchWithIndexResponsePresModel\r\n  FilterSearchWithIndexResponse = 'filterSearchWithIndexResponse',\r\n\r\n  // DPI_FilterShowChildrenResponse, having type FilterShowChildrenResponsePresModel\r\n  FilterShowChildrenResponse = 'filterShowChildrenResponse',\r\n\r\n  // DPI_EditDataServerConnection, having type EditDataServerConnectionPresModel\r\n  EditDataServerConnection = 'editDataServerConnection',\r\n\r\n  // DPI_ImagesEdit, having type ImagesEditPresModel\r\n  ImagesEdit = 'imagesEdit',\r\n\r\n  // DPI_BackgroundImage, having type BackgroundImagePresModel\r\n  BackgroundImage = 'backgroundImage',\r\n\r\n  // DPI_BackgroundImages, having type BackgroundImagePresModel[]\r\n  BackgroundImages = 'backgroundImages',\r\n\r\n  // DPI_Predicate, having type PredicatePresModel\r\n  Predicate = 'predicate',\r\n\r\n  // DPI_Predicates, having type PredicatePresModel[]\r\n  Predicates = 'predicates',\r\n\r\n  // DPI_ImagesEditResult, having type ImagesEditResultPresModel\r\n  ImagesEditResult = 'imagesEditResult',\r\n\r\n  // DPI_SortDialogPresModel, having type SortDialogPresModel\r\n  SortDialogPresModel = 'sortDialogPresModel',\r\n\r\n  // DPI_CompoundTableCalc, having type CompoundTableCalculationPresModel\r\n  CompoundTableCalc = 'compoundTableCalculationPresModel',\r\n\r\n  // DPI_TableCalc, having type TableCalculationPresModel\r\n  TableCalc = 'tableCalculationPresModel',\r\n\r\n  // DPI_TableCalcs, having type TableCalculationPresModel[]\r\n  TableCalcs = 'tableCalculationPresModels',\r\n\r\n  // DPI_TableCalcIdentifier, having type TableCalcIdentifierPresModel\r\n  TableCalcIdentifier = 'tableCalcIdentifier',\r\n\r\n  // DPI_NestedTableCalcInfo, having type NestedTableCalcInfoPresModel\r\n  NestedTableCalcInfo = 'nestedTableCalcInfo',\r\n\r\n  // DPI_NestedTableCalcInfos, having type NestedTableCalcInfoPresModel[]\r\n  NestedTableCalcInfos = 'nestedTableCalcInfos',\r\n\r\n  // DPI_Ordering, having type TableCalcOrderingPresModel\r\n  Ordering = 'tableCalcOrderingPresModel',\r\n\r\n  // DPI_Cumulative, having type CumulativeTableCalcPresModel\r\n  Cumulative = 'cumulativeTableCalcPresModel',\r\n\r\n  // DPI_ReferenceOptions, having type TableCalcReferenceOptionsPresModel\r\n  ReferenceOptions = 'tableCalcReferenceOptionsPresModel',\r\n\r\n  // DPI_Difference, having type DifferenceTableCalcPresModel\r\n  Difference = 'differenceTableCalcPresModel',\r\n\r\n  // DPI_Window, having type WindowTableCalcPresModel\r\n  Window = 'windowTableCalcPresModel',\r\n\r\n  // DPI_PercentTotal, having type PercentTotalTableCalcPresModel\r\n  PercentTotal = 'percentTotalTableCalcPresModel',\r\n\r\n  // DPI_Rank, having type RankTableCalcPresModel\r\n  Rank = 'rankTableCalcPresModel',\r\n\r\n  // DPI_Custom, having type CustomTableCalcPresModel\r\n  Custom = 'customTableCalcPresModel',\r\n\r\n  // DPI_WebDataUrl, having type WebDataUrlPresModel\r\n  WebDataUrl = 'webDataUrl',\r\n\r\n  // DPI_VisitedWebDataConnectors, having type WebDataUrlPresModel[]\r\n  VisitedWebDataConnectors = 'visitedWebDataConnectors',\r\n\r\n  // DPI_WebDataSessionUrls, having type WebDataUrlPresModel[]\r\n  WebDataSessionUrls = 'webDataSessionUrls',\r\n\r\n  // DPI_WebDataUrls, having type WebDataUrlPresModel[]\r\n  WebDataUrls = 'webDataUrls',\r\n\r\n  // DPI_FieldPicker, having type FieldPickerPresModel\r\n  FieldPicker = 'fieldPicker',\r\n\r\n  // DPI_DescribeField, having type DescribeFieldPresModel\r\n  DescribeField = 'describeField',\r\n\r\n  // DPI_ShowDataPresModel, having type ShowDataPresModel\r\n  ShowDataPresModel = 'showDataPresModel',\r\n\r\n  // DPI_DataTablePresModel, having type ShowDataTablePresModel\r\n  DataTablePresModel = 'dataTablePresModel',\r\n\r\n  // DPI_DataTablePresModels, having type ShowDataTablePresModel[]\r\n  DataTablePresModels = 'dataTablePresModels',\r\n\r\n  // DPI_SummaryTablePresModels, having type ShowDataTablePresModel[]\r\n  SummaryTablePresModels = 'summaryTablePresModels',\r\n\r\n  // DPI_RefreshAllExtractsPresModel, having type RefreshAllExtractsPresModel\r\n  RefreshAllExtractsPresModel = 'refeshAllExtractsPresModel',\r\n\r\n  // DPI_RefreshExtractDataSourcePresModel, having type RefreshExtractDataSourcePresModel\r\n  RefreshExtractDataSourcePresModel = 'refreshExtractDatasourcePresModel',\r\n\r\n  // DPI_RefreshExtractDataSourceList, having type RefreshExtractDataSourcePresModel[]\r\n  RefreshExtractDataSourceList = 'refreshExtractDatasourceList',\r\n\r\n  // DPI_ExtractHistoryPresModel, having type ExtractHistoryPresModel\r\n  ExtractHistoryPresModel = 'extractHistoryPresModel',\r\n\r\n  // DPI_ExtractHistoryItemPresModel, having type ExtractHistoryItemPresModel\r\n  ExtractHistoryItemPresModel = 'extractHistoryItem',\r\n\r\n  // DPI_ExtractHistoryList, having type ExtractHistoryItemPresModel[]\r\n  ExtractHistoryList = 'extractHistoryList',\r\n\r\n  // DPI_DataProviderPresModel, having type DataProviderPresModel\r\n  DataProviderPresModel = 'dataProviderPresModel',\r\n\r\n  // DPI_FormatItem, having type FormatItemPresModel\r\n  FormatItem = 'formatItem',\r\n\r\n  // DPI_FormatItemList, having type FormatItemPresModel[]\r\n  FormatItemList = 'formatItemList',\r\n\r\n  // DPI_FormatContainer, having type FormatContainerPresModel\r\n  FormatContainer = 'formatContainer',\r\n\r\n  // DPI_FormatPane, having type FormatPanePresModel\r\n  FormatPane = 'formatPane',\r\n\r\n  // DPI_FormatSection, having type FormatSectionPresModel\r\n  FormatSection = 'formatSection',\r\n\r\n  // DPI_CollapsibleSection, having type CollapsibleSectionPresModel\r\n  CollapsibleSection = 'collapsibleSection',\r\n\r\n  // DPI_CompositeContainer, having type CompositeContainerPresModel\r\n  CompositeContainer = 'compositeContainer',\r\n\r\n  // DPI_UnitContainer, having type UnitContainerPresModel\r\n  UnitContainer = 'unitContainer',\r\n\r\n  // DPI_TabGroup, having type TabGroupPresModel\r\n  TabGroup = 'tabGroup',\r\n\r\n  // DPI_Tab, having type TabPresModel\r\n  Tab = 'tab',\r\n\r\n  // DPI_FormatControl, having type FormatControlPresModel\r\n  FormatControl = 'formatControl',\r\n\r\n  // DPI_TextControl, having type TextControlPresModel\r\n  TextControl = 'textControl',\r\n\r\n  // DPI_NumericControl, having type NumericControlPresModel\r\n  NumericControl = 'numericControl',\r\n\r\n  // DPI_ColorControl, having type ColorControlPresModel\r\n  ColorControl = 'colorControl',\r\n\r\n  // DPI_ToggleControl, having type ToggleControlPresModel\r\n  ToggleControl = 'toggleControl',\r\n\r\n  // DPI_SelectorControl, having type SelectorControlPresModel\r\n  SelectorControl = 'enumStringStyle',\r\n\r\n  // DPI_StatsAnalyticSpec, having type StatsAnalyticSpecPresModel\r\n  StatsAnalyticSpec = 'statsAnalyticSpec',\r\n\r\n  // DPI_ClusterSpec, having type ClusterSpecPresModel\r\n  ClusterSpec = 'clusteringSpec',\r\n\r\n  // DPI_ClusterResults, having type ClusterResultsPresModel\r\n  ClusterResults = 'clusterResults',\r\n\r\n  // DPI_ClusterUnit, having type ClusterUnitPresModel\r\n  ClusterUnit = 'cluster',\r\n\r\n  // DPI_ClusterUnits, having type ClusterUnitPresModel[]\r\n  ClusterUnits = 'clusterUnitPresModels',\r\n\r\n  // DPI_ClusterFieldANOVA, having type ClusterFieldANOVAPresModel\r\n  ClusterFieldANOVA = 'clusterFieldAnova',\r\n\r\n  // DPI_ClusterFieldANOVATable, having type ClusterFieldANOVAPresModel[]\r\n  ClusterFieldANOVATable = 'clusterFieldAnovaTablePresModel',\r\n\r\n  // DPI_ClusterEdit, having type ClusterEditPresModel\r\n  ClusterEdit = 'clusterEditPresModel',\r\n\r\n  // DPI_ClusterDescription, having type ClusterDescribePresModel\r\n  ClusterDescription = 'clusterDescription',\r\n\r\n  // DPI_OutlierResults, having type OutlierResultsPresModel\r\n  OutlierResults = 'outlierResults',\r\n\r\n  // DPI_ConnectToDataServerSourceResult, having type ConnectToDataServerSourceResultPresModel\r\n  ConnectToDataServerSourceResult = 'connectToDataServerSourceResult',\r\n\r\n  // DPI_DataServerConnectionReturnStatus, having type ConnectToDataServerSourceResultPresModel\r\n  DataServerConnectionReturnStatus = 'dataServerConnectionReturnStatus',\r\n\r\n  // DPI_WebQuantitativeColorDialog, having type WebQuantitativeColorDialogPresModel\r\n  WebQuantitativeColorDialog = 'quantitativeColorDialog',\r\n\r\n  // DPI_WebCategoricalColorDialog, having type WebCategoricalColorDialogPresModel\r\n  WebCategoricalColorDialog = 'categoricalColorDialog',\r\n\r\n  // DPI_WebSaveDatasourceDialog, having type WebSaveDatasourceDialogPresModel\r\n  WebSaveDatasourceDialog = 'saveDatasourceDialog',\r\n\r\n  // DPI_BorderStyleSpec, having type StyleSpecPresModel\r\n  BorderStyleSpec = 'borderStyleSpec',\r\n\r\n  // DPI_HaloStyleSpec, having type StyleSpecPresModel\r\n  HaloStyleSpec = 'haloStyleSpec',\r\n\r\n  // DPI_MarksColorUberEffects, having type MarksColorUberEffectsPresModel\r\n  MarksColorUberEffects = 'marksColorUberEffects',\r\n\r\n  // DPI_CategoricalColorEncoding, having type CategoricalColorEncodingPresModel\r\n  CategoricalColorEncoding = 'categoricalColorEncoding',\r\n\r\n  // DPI_CategoricalShapeEncoding, having type CategoricalShapeEncodingPresModel\r\n  CategoricalShapeEncoding = 'categoricalShapeEncoding',\r\n\r\n  // DPI_ShapePalettePresModel, having type ShapePalettePresModel\r\n  ShapePalettePresModel = 'shapePalettePresModel',\r\n\r\n  // DPI_ShapePalettePresModels, having type ShapePalettePresModel[]\r\n  ShapePalettePresModels = 'shapePalettePresModels',\r\n\r\n  // DPI_DataSourceDateProperties, having type DataSourceDatePropertiesPresModel\r\n  DataSourceDateProperties = 'datasourceDateProperties',\r\n\r\n  // DPI_DatePropertiesDateFormat, having type DatePropertiesDateFormatPresModel\r\n  DatePropertiesDateFormat = 'datePropertiesDateFormat',\r\n\r\n  // DPI_DatePropertiesDateFormats, having type DatePropertiesDateFormatPresModel[]\r\n  DatePropertiesDateFormats = 'datePropertiesDateFormats',\r\n\r\n  // DPI_HierarchySelect, having type HierarchySelectModel\r\n  HierarchySelect = 'hierarchySelect',\r\n\r\n  // DPI_HierarchySelectMember, having type HierarchySelectMemberPresModel\r\n  HierarchySelectMember = 'hierarchySelectMember',\r\n\r\n  // DPI_HierarchySelectMemberList, having type HierarchySelectMemberPresModel[]\r\n  HierarchySelectMemberList = 'hierarchySelectMemberList',\r\n\r\n  // DPI_HierarchySetDefaultMember, having type HierarchySetDefaultMemberPresModel\r\n  HierarchySetDefaultMember = 'hierarchySetDefaultMember',\r\n\r\n  // DPI_SemiStructSchema, having type SemiStructSchemaPresModel\r\n  SemiStructSchema = 'semiStructSchema',\r\n\r\n  // DPI_SemiStructSchemaMember, having type SemiStructSchemaMemberPresModel\r\n  SemiStructSchemaMember = 'semiStructSchemaMember',\r\n\r\n  // DPI_SemiStructSchemaMemberList, having type SemiStructSchemaMemberPresModel[]\r\n  SemiStructSchemaMemberList = 'semiStructSchemaMemberList',\r\n\r\n  // DPI_ParameterEditInfo, having type ParameterEditInfoPresModel\r\n  ParameterEditInfo = 'parameterEditInfo',\r\n\r\n  // DPI_ProductParameterInfo, having type ProductParameterInfoPresModel\r\n  ProductParameterInfo = 'productParameterInfo',\r\n\r\n  // DPI_CaptionedDatasourceField, having type CaptionedDatasourceInfoPresModel\r\n  CaptionedDatasourceField = 'captionedDatasourceField',\r\n\r\n  // DPI_CaptionedDatasourceFields, having type CaptionedDatasourceInfoPresModel[]\r\n  CaptionedDatasourceFields = 'captionedDatasourceFields',\r\n\r\n  // DPI_EditedParameterRangeDomain, having type ParameterRangeDomainPresModel\r\n  EditedParameterRangeDomain = 'editedParameterRangeDomain',\r\n\r\n  // DPI_ParameterRangeDomain, having type ParameterRangeDomainPresModel\r\n  ParameterRangeDomain = 'parameterRangeDomain',\r\n\r\n  // DPI_ParameterListDomain, having type ParameterListDomainPresModel\r\n  ParameterListDomain = 'parameterListDomain',\r\n\r\n  // DPI_ParameterListDomainMember, having type ParameterListDomainMemberPresModel\r\n  ParameterListDomainMember = 'parameterListDomainMember',\r\n\r\n  // DPI_ParameterListDomainMembers, having type ParameterListDomainMemberPresModel[]\r\n  ParameterListDomainMembers = 'parameterListDomainMembers',\r\n\r\n  // DPI_IndexedDomainMember, having type IndexedDomainMemberPresModel\r\n  IndexedDomainMember = 'indexedDomainMember',\r\n\r\n  // DPI_IndexedDomainMembers, having type IndexedDomainMemberPresModel[]\r\n  IndexedDomainMembers = 'indexedDomainMembers',\r\n\r\n  // DPI_NewIndexedDomainMembers, having type IndexedDomainMemberPresModel[]\r\n  NewIndexedDomainMembers = 'newIndexedDomainMembers',\r\n\r\n  // DPI_ParameterListDomainDiff, having type parameter-list-domain-diff\r\n  ParameterListDomainDiff = 'parameterListDomainDiff',\r\n\r\n  // DPI_IndexRange, having type IndexRangePresModel\r\n  IndexRange = 'indexRange',\r\n\r\n  // DPI_IndexRanges, having type IndexRangePresModel[]\r\n  IndexRanges = 'indexRanges',\r\n\r\n  // DPI_CategoricalFind, having type CategoricalFindPresModel\r\n  CategoricalFind = 'categoricalFind',\r\n\r\n  // DPI_CaptionedDataValue, having type CaptionedDataValuePresModel\r\n  CaptionedDataValue = 'captionedDataValue',\r\n\r\n  // DPI_SelectedValueCaption, having type CaptionedDataValuePresModel\r\n  SelectedValueCaption = 'selectedValueCaption',\r\n\r\n  // DPI_DataValueCaptionList, having type CaptionedDataValuePresModel[]\r\n  DataValueCaptionList = 'dataValueCatpionList',\r\n\r\n  // DPI_RangeDataValue, having type RangeDataValuePresModel\r\n  RangeDataValue = 'rangeDataValue',\r\n\r\n  // DPI_ParameterRangeDataValue, having type RangeDataValuePresModel\r\n  ParameterRangeDataValue = 'parameterRangeDataValue',\r\n\r\n  // DPI_DataValueRangeCaptions, having type DataValueRangeCaptionsPresModel\r\n  DataValueRangeCaptions = 'dataValueRangeCaptions',\r\n\r\n  // DPI_IndependentDimension, having type IndependentDimensionPresModel\r\n  IndependentDimension = 'independentDimension',\r\n\r\n  // DPI_IndependentDimensions, having type IndependentDimensionPresModel[]\r\n  IndependentDimensions = 'independentDimensions',\r\n\r\n  // DPI_AttributePerspective, having type PerspectivePresModel\r\n  AttributePerspective = 'attributePerspective',\r\n\r\n  // DPI_CubePerspective, having type PerspectivePresModel\r\n  CubePerspective = 'cubePerspective',\r\n\r\n  // DPI_AttributePerspectives, having type PerspectivePresModel[]\r\n  AttributePerspectives = 'attributePerspectives',\r\n\r\n  // DPI_CalculatedMembersForEditingPresModel, having type EditCalculatedMembersPresModel\r\n  CalculatedMembersForEditingPresModel = 'calculatedMembersForEditingPresmodel',\r\n\r\n  // DPI_CalculatedMember, having type CalculatedMemberPresModel\r\n  CalculatedMember = 'calculatedMember',\r\n\r\n  // DPI_NewCalculatedMember, having type CalculatedMemberPresModel\r\n  NewCalculatedMember = 'newCalculatedMember',\r\n\r\n  // DPI_UpdatedCalculatedMember, having type CalculatedMemberPresModel\r\n  UpdatedCalculatedMember = 'updatedCalculatedMember',\r\n\r\n  // DPI_CalculatedMembersList, having type CalculatedMemberPresModel[]\r\n  CalculatedMembersList = 'calculatedMembersList',\r\n\r\n  // DPI_CalculatedMemberHierarchyItem, having type CalculatedMemberHierarchyItemPresModel\r\n  CalculatedMemberHierarchyItem = 'calculatedMemberHierarchyItem',\r\n\r\n  // DPI_CalculatedMemberHierarchyList, having type CalculatedMemberHierarchyItemPresModel[]\r\n  CalculatedMemberHierarchyList = 'calculatedMemberHierarchyList',\r\n\r\n  // DPI_SummaryCardPresModel, having type SummaryCardPresModel\r\n  SummaryCardPresModel = 'summaryCard',\r\n\r\n  // DPI_MeasureSummary, having type MeasureSummaryPresModel\r\n  MeasureSummary = 'measureSummary',\r\n\r\n  // DPI_MeasureSummaryList, having type MeasureSummaryPresModel[]\r\n  MeasureSummaryList = 'measureSummaryList',\r\n\r\n  // DPI_AnnotationPresModel, having type AnnotationPresModel\r\n  AnnotationPresModel = 'annotation',\r\n\r\n  // DPI_AnnotationList, having type AnnotationPresModel[]\r\n  AnnotationList = 'annotationList',\r\n\r\n  // DPI_AnnotationShapeStyle, having type AnnotationShapeStylePresModel\r\n  AnnotationShapeStyle = 'annotationShapeStyle',\r\n\r\n  // DPI_Telemetry, having type TelemetryPresModel\r\n  Telemetry = 'telemetry',\r\n\r\n  // DPI_DataSourceTelemetry, having type DataSourceTelemetryPresModel\r\n  DataSourceTelemetry = 'dataSourceTelemetry',\r\n\r\n  // DPI_DataSourceTelemetryList, having type DataSourceTelemetryPresModel[]\r\n  DataSourceTelemetryList = 'dataSourceTelemetryList',\r\n\r\n  // DPI_VisualSpecificationTelemetry, having type VisualSpecificationTelemetryPresModel\r\n  VisualSpecificationTelemetry = 'visualSpecificationTelemetry',\r\n\r\n  // DPI_VisualSpecificationTelemetryList, having type VisualSpecificationTelemetryPresModel[]\r\n  VisualSpecificationTelemetryList = 'visualSpecificationTelemetryList',\r\n\r\n  // DPI_UnderlyingDataTable, having type UnderlyingDataTablePresModel\r\n  UnderlyingDataTable = 'underlyingDataTable',\r\n\r\n  // DPI_UnderlyingDataTables, having type UnderlyingDataTablePresModel[]\r\n  UnderlyingDataTables = 'underlyingDataTables',\r\n\r\n  // DPI_UnderlyingDataTableColumn, having type UnderlyingDataTableColumnPresModel\r\n  UnderlyingDataTableColumn = 'underlyingDataTableColumn',\r\n\r\n  // DPI_UnderlyingDataTableColumns, having type UnderlyingDataTableColumnPresModel[]\r\n  UnderlyingDataTableColumns = 'underlyingDataTableColumns',\r\n\r\n  // DPI_PageCacheID, having type PageCacheIDPresModel\r\n  PageCacheID = 'pageCacheId',\r\n\r\n  // DPI_RelationalPageCacheID, having type PageCacheIDPresModel\r\n  RelationalPageCacheID = 'relationalPageCacheId',\r\n\r\n  // DPI_SearchResultsCacheID, having type PageCacheIDPresModel\r\n  SearchResultsCacheID = 'searchResultsCacheId',\r\n\r\n  // DPI_PageInfo, having type PageInfoPresModel\r\n  PageInfo = 'pageInfo',\r\n\r\n  // DPI_RowColPair, having type RowColPairPresModel\r\n  RowColPair = 'rowColPair',\r\n\r\n  // DPI_TopLeftRowCol, having type RowColPairPresModel\r\n  TopLeftRowCol = 'topLeftRowCol',\r\n\r\n  // DPI_BotRightRowCol, having type RowColPairPresModel\r\n  BotRightRowCol = 'botRightRowCol',\r\n\r\n  // DPI_RowColPairs, having type RowColPairPresModel[]\r\n  RowColPairs = 'rowColPairs',\r\n\r\n  // DPI_TableViewCacheInfo, having type TableViewCachePresModel\r\n  TableViewCacheInfo = 'tableViewCacheInfo',\r\n\r\n  // DPI_TableViewInfo, having type tableViewInfoPresModel\r\n  TableViewInfo = 'tableViewInfo',\r\n\r\n  // DPI_TableViewColumnInfo, having type TableViewColumnInfoPresModel\r\n  TableViewColumnInfo = 'tableViewColumnInfo',\r\n\r\n  // DPI_TableViewColumns, having type TableViewColumnInfoPresModel[]\r\n  TableViewColumns = 'tableViewColumns',\r\n\r\n  // DPI_TableViewPageItem, having type TableViewPageItemPresModel\r\n  TableViewPageItem = 'tableViewPageItem',\r\n\r\n  // DPI_TableViewPageColumns, having type TableViewPageItemPresModel[]\r\n  TableViewPageColumns = 'tableViewPageColumns',\r\n\r\n  // DPI_TableViewPageRow, having type TableViewPageRowPresModel\r\n  TableViewPageRow = 'tableViewPageRow',\r\n\r\n  // DPI_TableViewPageRows, having type TableViewPageRowPresModel[]\r\n  TableViewPageRows = 'tableViewPageRows',\r\n\r\n  // DPI_TableViewPage, having type TableViewPagePresModel\r\n  TableViewPage = 'tableViewPage',\r\n\r\n  // DPI_CategoricalValuePicker, having type CategoricalValuePickerPresModel\r\n  CategoricalValuePicker = 'categoricalValuePicker',\r\n\r\n  // DPI_AnnotationShapeBorderStyle, having type LineStylePresModel\r\n  AnnotationShapeBorderStyle = 'annotationShapeBorderStyle',\r\n\r\n  // DPI_AnotationShapeStrokeStyle, having type LineStylePresModel\r\n  AnotationShapeStrokeStyle = 'annotationShapeStrokeStyle',\r\n\r\n  // DPI_CategoricalBinEditorPresModel, having type CategoricalBinEditorPresModel\r\n  CategoricalBinEditorPresModel = 'categoricalBinEditor',\r\n\r\n  // DPI_CategoricalBinItem, having type CategoricalBinItemPresModel\r\n  CategoricalBinItem = 'categoricalBinItemPresModel',\r\n\r\n  // DPI_CategoricalBinItems, having type CategoricalBinItemPresModel[]\r\n  CategoricalBinItems = 'categoricalBinItemPresModels',\r\n\r\n  // DPI_MeasurePickerFieldInfo, having type MeasurePickerFieldInfoPresModel\r\n  MeasurePickerFieldInfo = 'measurePickerFieldInfo',\r\n\r\n  // DPI_MeasurePickerFields, having type MeasurePickerFieldInfoPresModel[]\r\n  MeasurePickerFields = 'measurePickerFields',\r\n\r\n  // DPI_MeasureAggregationInfo, having type MeasureAggregationInfoPresModel\r\n  MeasureAggregationInfo = 'measureAggregationInfo',\r\n\r\n  // DPI_MeasureAggregations, having type MeasureAggregationInfoPresModel[]\r\n  MeasureAggregations = 'measureAggregations',\r\n\r\n  // DPI_TuplePair, having type TuplePairPresModel\r\n  TuplePair = 'tuplePair',\r\n\r\n  // DPI_DimensionBound, having type DimensionBoundPresModel\r\n  DimensionBound = 'dimensionBound',\r\n\r\n  // DPI_PerspectiveBounds, having type DimensionBoundPresModel[]\r\n  PerspectiveBounds = 'perspectiveBounds',\r\n\r\n  // DPI_FilterPerspectiveInfoPresModel, having type FilterPerspectiveInfoPresModel\r\n  FilterPerspectiveInfoPresModel = 'filterPerspectiveInfo',\r\n\r\n  // DPI_TableRelevance, having type TableRelevancePresModel\r\n  TableRelevance = 'tableRelevance',\r\n\r\n  // DPI_AddInRegistrationPresModel, having type AddInRegistrationPresModel\r\n  AddInRegistrationPresModel = 'addInRegistrationPresModel',\r\n\r\n  // DPI_AddInRegistrationPresModelList, having type AddInRegistrationPresModel[]\r\n  AddInRegistrationPresModelList = 'addInRegistrationPresModelList',\r\n\r\n  // DPI_AddInDashboardAuthoringWidget, having type AddInDashboardWidgetPresModel\r\n  AddInDashboardAuthoringWidget = 'addInDashboardAuthoringWidgetPresModel',\r\n\r\n  // DPI_AddInInstance, having type AddInInstancePresModel\r\n  AddInInstance = 'addInInstancePresModel',\r\n\r\n  // DPI_AddInLocator, having type AddInLocatorPresModel\r\n  AddInLocator = 'addInLocatorPresModel',\r\n\r\n  // DPI_AddInContext, having type AddInContext\r\n  AddInContext = 'addInContext',\r\n\r\n  // DPI_AddInMode, having type AddInMode\r\n  AddInMode = 'addInMode',\r\n\r\n  // DPI_SetAxisDataValueResult, having type SetAxisDataValueResult\r\n  SetAxisDataValueResult = 'setAxisDataValueResult',\r\n\r\n  // DPI_AxisExtentStartType, having type AxisExtentType\r\n  AxisExtentStartType = 'axisExtentStartType',\r\n\r\n  // DPI_AxisExtentEndType, having type AxisExtentType\r\n  AxisExtentEndType = 'axisExtentEndType',\r\n\r\n  // DPI_AxisExtentsType, having type AxisExtentType\r\n  AxisExtentsType = 'axisExtentsType',\r\n\r\n  // DPI_AddInEnvironment, having type AddInEnvironmentPresModel\r\n  AddInEnvironment = 'addInEnvironmentPresModel',\r\n\r\n  // DPI_AddInDashboardInfo, having type AddInDashboardInfoPresModel\r\n  AddInDashboardInfo = 'addInDashboardInfoPresModel',\r\n\r\n  // DPI_AddInSettingsInfo, having type AddInSettingsInfoPresModel\r\n  AddInSettingsInfo = 'addInSettingsInfo',\r\n\r\n  // DPI_AddInBootstrapInfo, having type AddInBootstrapInfoPresModel\r\n  AddInBootstrapInfo = 'addInBootstrapInfo',\r\n\r\n  // DPI_AddInDebugSettings, having type AddInDebugSettingsPresModel\r\n  AddInDebugSettings = 'addInDebugSettings',\r\n\r\n  // DPI_RichText, having type RichTextPresModel\r\n  RichText = 'richText',\r\n\r\n  // DPI_RichTextKeywordSubList, having type RichTextKeywordSubListPresModel\r\n  RichTextKeywordSubList = 'richTextKeywordsSublist',\r\n\r\n  // DPI_RichTextKeywordSubLists, having type RichTextKeywordSubListPresModel[]\r\n  RichTextKeywordSubLists = 'richTextKeywordSublists',\r\n\r\n  // DPI_RichTextKeywordList, having type RichTextKeywordListPresModel\r\n  RichTextKeywordList = 'richTextKeywordsList',\r\n\r\n  // DPI_RichTextBlockStyle, having type RichTextBlockStylePresModel\r\n  RichTextBlockStyle = 'richTextBlockStyle',\r\n\r\n  // DPI_RichTextContentStyle, having type RichTextContentStylePresModel\r\n  RichTextContentStyle = 'richTextContentStyle'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/gen-src/preslayer/Params.ts\n **/","import { ParameterId as Api, VerbId as ApiVerbId, VersionNumber } from '@tableau/api-internal-contract';\r\n\r\nimport {\r\n  DocCommands as PresLayerDocCommandId,\r\n  SrvCommands as PresLayerSrvCommandId,\r\n  UICommands as PresLayerUICommandId\r\n} from '../../gen-src/preslayer/CommandIds';\r\n\r\nimport { ParameterId as PL } from '../../gen-src/preslayer/Params';\r\nimport { CommandMappingRegistry } from './CommandMappingRegistry';\r\nimport { CommandNamespace, CommandParameter, CommandRegistration } from './CommandRegistration';\r\n\r\nexport class CommandMappingRegistryFactory {\r\n  /**\r\n   * Creates and populates a new CommandMappingRegistry for the specific version number requested\r\n   *\r\n   * @static\r\n   * @param {VersionNumber} versionNumber\r\n   * @param {boolean} runningInDesktop\r\n   * @returns {CommandMappingRegistry}\r\n   * @memberof CommandMappingRegistryFactory\r\n   */\r\n  public static createCommandMappingRegistry(versionNumber: VersionNumber, runningInDesktop: boolean): CommandMappingRegistry {\r\n    let result = new CommandMappingRegistry();\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.InitializeExtension,\r\n      PresLayerDocCommandId.InitializeAddInInstance,\r\n      [ new CommandParameter(Api.ExtensionLocator, PL.AddInLocator) ],\r\n      new CommandParameter(Api.ExtensionBootstrapInfo, PL.AddInBootstrapInfo)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetUnderlyingData,\r\n      PresLayerDocCommandId.GetUnderlyingData,\r\n      [ new CommandParameter(Api.IgnoreAliases, PL.IgnoreAliases),\r\n        new CommandParameter(Api.IgnoreSelection, PL.IgnoreSelection),\r\n        new CommandParameter(Api.IncludeAllColumns, PL.IncludeAllColumns),\r\n        new CommandParameter(Api.MaxRows, PL.MaxRows),\r\n        new CommandParameter(Api.VisualId, PL.VisualIDPM) ],\r\n      new CommandParameter(Api.UnderlyingDataTable, PL.UnderlyingDataTable)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetDataSummaryData,\r\n      PresLayerDocCommandId.GetSummaryData,\r\n      [ new CommandParameter(Api.IgnoreAliases, PL.IgnoreAliases),\r\n        new CommandParameter(Api.IgnoreSelection, PL.IgnoreSelection),\r\n        new CommandParameter(Api.VisualId, PL.VisualIDPM) ],\r\n      new CommandParameter(Api.UnderlyingSummaryDataTable, PL.UnderlyingDataTable)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetDataSourceData,\r\n      PresLayerDocCommandId.GetDataSourceData,\r\n      [ new CommandParameter(Api.DataSourceId, PL.Datasource),\r\n        new CommandParameter(Api.IgnoreAliases, PL.IgnoreAliases),\r\n        new CommandParameter(Api.MaxRows, PL.MaxRows),\r\n        new CommandParameter(Api.ColumnsToInclude, PL.FieldDisplayNames) ],\r\n      new CommandParameter(Api.DataSourceDataTable, PL.UnderlyingDataTable)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.ApplyCategoricalFilter,\r\n      PresLayerDocCommandId.CategoricalFilter,\r\n      [ new CommandParameter(Api.FieldName, PL.QualifiedFieldCaption),\r\n        new CommandParameter(Api.FilterValues, PL.FilterAliases),\r\n        new CommandParameter(Api.FilterUpdateType, PL.FilterUpdateType),\r\n        new CommandParameter(Api.IsExcludeMode, PL.Exclude, true),\r\n        new CommandParameter(Api.VisualId, PL.Worksheet),\r\n        new CommandParameter(Api.VisualId, PL.Dashboard)],\r\n      new CommandParameter(Api.FieldName, PL.FieldCaption)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.ApplyRangeFilter,\r\n      PresLayerDocCommandId.RangeFilter,\r\n      [ new CommandParameter(Api.FieldName, PL.QualifiedFieldCaption),\r\n        new CommandParameter(Api.FilterRangeMin, PL.RangeMin, true),\r\n        new CommandParameter(Api.FilterRangeMax, PL.RangeMax, true),\r\n        new CommandParameter(Api.FilterRangeNullOption, PL.Included, true),\r\n        new CommandParameter(Api.VisualId, PL.Worksheet),\r\n        new CommandParameter(Api.VisualId, PL.Dashboard)],\r\n      new CommandParameter(Api.FieldName, PL.FieldCaption)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.ClearFilter,\r\n      PresLayerDocCommandId.ResetFilter,\r\n      [ new CommandParameter(Api.FieldName, PL.QualifiedFieldCaption),\r\n        new CommandParameter(Api.VisualId, PL.Worksheet),\r\n        new CommandParameter(Api.VisualId, PL.Dashboard)],\r\n      new CommandParameter(Api.FieldName, PL.FieldCaption)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetSelectedMarks,\r\n      PresLayerDocCommandId.GetSelectionData,\r\n      [ new CommandParameter(Api.VisualId, PL.VisualIDPM) ],\r\n      new CommandParameter(Api.SelectedData, PL.SelectionData)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetHighlightedMarks,\r\n      PresLayerDocCommandId.GetHighlightedData,\r\n      [ new CommandParameter(Api.VisualId, PL.VisualIDPM) ],\r\n      new CommandParameter(Api.HighlightedData, PL.HighlightedData)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.SaveExtensionSettings,\r\n      PresLayerDocCommandId.SaveAddInSettings,\r\n      [ new CommandParameter(Api.ExtensionLocator, PL.AddInLocator),\r\n        new CommandParameter(Api.SettingsValues, PL.AddInSettings)],\r\n      new CommandParameter(Api.ExtensionSettingsInfo, PL.AddInSettingsInfo)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetParametersForSheet,\r\n      PresLayerDocCommandId.GetParameterModels,\r\n      [],\r\n      new CommandParameter(Api.ParameterInfos, PL.ParameterCtrls)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.FindParameter,\r\n      PresLayerDocCommandId.FindParameterModel,\r\n      [ new CommandParameter(Api.ParameterCaption, PL.FieldCaption, true),\r\n        new CommandParameter(Api.ParameterFieldName, PL.FieldNameString, true)],\r\n      // We might not get a response if the parameter isn't found\r\n      new CommandParameter(Api.ParameterInfo, PL.ParameterCtrl, true)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.ChangeParameterValue,\r\n      PresLayerDocCommandId.SetParameterValue,\r\n      [ new CommandParameter(Api.ParameterFieldName, PL.GlobalFieldName),\r\n        new CommandParameter(Api.ParameterValue, PL.ValueStr)],\r\n      new CommandParameter(Api.ParameterInfo, PL.ParameterCtrl)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.ClearSelectedMarks,\r\n      PresLayerDocCommandId.ClearSelectedMarks,\r\n      [new CommandParameter(Api.VisualId, PL.VisualIDPM)]));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.SelectByValue,\r\n      PresLayerDocCommandId.SelectByValue,\r\n      [new CommandParameter(Api.VisualId, PL.VisualIDPM),\r\n        new CommandParameter(Api.Selection, PL.Selection, true),\r\n        new CommandParameter(Api.SelectionUpdateType, PL.SelectionUpdateType),\r\n        new CommandParameter(Api.HierValSelectionModels, PL.HierValSelectionModels, true),\r\n        new CommandParameter(Api.DimValSelectionModels, PL.DimValSelectionModels, true),\r\n        new CommandParameter(Api.QuantRangeSelectionModels, PL.QuantRangeSelectionModels, true)]));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetDataSources,\r\n      PresLayerDocCommandId.GetSchema,\r\n      [],\r\n      new CommandParameter(Api.DataSchema, PL.DataSchema)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.RefreshDataSource,\r\n      (runningInDesktop) ? PresLayerUICommandId.RefreshDataSourceUI : PresLayerSrvCommandId.RefreshData,\r\n      [new CommandParameter(Api.DataSourceId, PL.Datasource)],\r\n      undefined,\r\n      (runningInDesktop) ? CommandNamespace.TabUI : CommandNamespace.TabSrv));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetFilters,\r\n      PresLayerDocCommandId.GetWorksheetFilters,\r\n      [new CommandParameter(Api.VisualId, PL.VisualIDPM)],\r\n      new CommandParameter(Api.WorksheetFilters, PL.FiltersInfo)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetCategoricalDomain,\r\n      PresLayerDocCommandId.GetCategoricalDomain,\r\n      [new CommandParameter(Api.VisualId, PL.VisualIDPM),\r\n       new CommandParameter(Api.FieldId, PL.FieldName),\r\n       new CommandParameter(Api.DomainType, PL.FilterDomainType)],\r\n       new CommandParameter(Api.CategoricalDomain, PL.CategoricalDomain)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetRangeDomain,\r\n      PresLayerDocCommandId.GetQuantitativeDomain,\r\n      [new CommandParameter(Api.VisualId, PL.VisualIDPM),\r\n       new CommandParameter(Api.FieldId, PL.FieldName),\r\n       new CommandParameter(Api.DomainType, PL.FilterDomainType)],\r\n       new CommandParameter(Api.QuantitativeDomain, PL.QuantitativeDomain)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetJoinDescription,\r\n      PresLayerDocCommandId.GetJoinDescriptionPresModel,\r\n      [new CommandParameter(Api.DataSourceId, PL.Datasource)],\r\n      new CommandParameter(Api.JoinDescription, PL.JoinDescription)));\r\n\r\n    result.addCommand(new CommandRegistration(\r\n      ApiVerbId.GetConnectionDescriptionSummaries,\r\n      PresLayerDocCommandId.GetConnectionDescriptionSummaryPresModels,\r\n      [new CommandParameter(Api.DataSourceId, PL.Datasource)],\r\n      new CommandParameter(Api.ConnectionDescriptionSummaries, PL.ConnectionDescriptionSummaries)));\r\n\r\n    return result;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/CommandMappingRegistryFactory.ts\n **/","/* tslint:disable */\r\n// -----------------------------------------------------------------------------\r\n//\r\n// This file is the copyrighted property of Tableau Software and is protected\r\n// by registered patents and other applicable U.S. and international laws and\r\n// regulations.\r\n//\r\n// Unlicensed use of the contents of this file is prohibited. Please refer to\r\n// the NOTICES.txt file for further details.\r\n//\r\n// -----------------------------------------------------------------------------\r\n// WARNING: Computer generated file.  Do not hand modify.\r\n// DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/commands-enum-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-cmd-wrappers.data']\r\n\r\nexport enum DocCommands {\r\n\r\n    // Saves the settings for the specified add-in id\r\n    SaveAddInSettings = 'save-add-in-settings',\r\n\r\n    // Gets the pres model for an add-in instance.\r\n    GetAddInInstancePresModel = 'get-add-in-instance-pres-model',\r\n\r\n    // Gets the pres model for the dashboard authoring widget for add-ins.\r\n    GetAddInDashboardAuthoringWidgetPresModel = 'get-add-in-dashboard-authoring-widget-pres-model',\r\n\r\n    // Gets the necessary information for an add-in to initialize itself.\r\n    InitializeAddInInstance = 'initialize-add-in-instance',\r\n\r\n    // Enables or disable javascript debugging of an add-in.\r\n    SetAddInJsDebuggingEnabled = 'set-add-in-js-debugging-enabled',\r\n\r\n    // Whether or not we should pause before loading. If missing, toggle the value\r\n    SetPauseBeforeLoadingAddIn = 'set-pause-before-loading-add-in',\r\n\r\n    // Reloads the Add-In widget and web page.\r\n    ReloadAddIn = 'reload-add-in',\r\n\r\n    // Retrieves the context menu for a dashboard add-in.\r\n    GetAddInZoneContextMenu = 'get-add-in-zone-context-menu',\r\n\r\n    // Gets the pres model which indicates what the debug settings for add-ins is.\r\n    GetAddInDebugSettingsPresModel = 'get-add-in-debug-settings-pres-model',\r\n\r\n    // Primary use is for building context menus\r\n    IsSelectionAnEditableParameter = 'is-selection-an-editable-parameter',\r\n\r\n    // Check if selection can be used as base for creating a new parameter. Primary use is for building context menus\r\n    GetCreateParameterState = 'get-create-parameter-state',\r\n\r\n    // Uses EditParameter to get and return info about the presmodel without maintaining the controller\r\n    GetParameterEditInfo = 'get-parameter-edit-info',\r\n\r\n    // Initialize the controller and its stored parameter then return a populated presmodel\r\n    CreateParameter = 'create-parameter',\r\n\r\n    // Same underlying logic as CreateParameter but edits rather than creating a new parameter\r\n    EditParameter_New = 'edit-parameter-new',\r\n\r\n    // Add a member of a parameter domain. Changes are applied to intermediate state and saved on commit\r\n    AddParameterMember = 'add-parameter-member',\r\n\r\n    // Edit a member of a parameter domain. Changes are applied to intermediate state and saved on commit\r\n    EditParameterMember = 'edit-parameter-member',\r\n\r\n    // Delete a series of ranges of members from the parameter list.\r\n    DeleteParameterMembers = 'delete-parameter-members',\r\n\r\n    // Copy a series of ranges of members of a parameter list\r\n    CopyParameterMembers = 'copy-parameter-members',\r\n\r\n    // Move a series of ranges of members of a parameter list\r\n    MoveParameterMembers = 'move-parameter-members',\r\n\r\n    // Change domain of a parameter. Changes are applied to intermediate state and saved on commit\r\n    EditParameterDomainType = 'edit-parameter-domain-type',\r\n\r\n    // Change datatype of a parameter. Changes are applied to intermediate state and saved on commit\r\n    EditParameterDataType = 'edit-parameter-data-type',\r\n\r\n    // Change display format of a parameter. Changes are applied to intermediate state and saved on commit\r\n    EditParameterFormat = 'edit-parameter-format',\r\n\r\n    // Validate changes to a parameter's range domain and apply to intermediate state. Changes are saved on commit\r\n    EditParameterRange = 'edit-parameter-range',\r\n\r\n    // Edit the value of a non-list domain parameter\r\n    EditParameterValue = 'edit-parameter-value',\r\n\r\n    // Edit the value of a list domain parameter\r\n    EditParameterValueIndex = 'edit-parameter-value-index',\r\n\r\n    // Update the parameter caption and description - used to keep backend in sync. No verification/return is requried.\r\n    EditParameterDisplayInfo = 'edit-parameter-display-info',\r\n\r\n    // Update the domain of the parameter using a field (column or parameter) as a base\r\n    UpdateParameterFromField = 'update-parameter-from-field',\r\n\r\n    // Update the list domain of a parameter from a plain text representation of values\r\n    ParseParameterListDomain = 'parse-parameter-list-domain',\r\n\r\n    // Clears the parameter's domain of all members\r\n    ClearParameterListDomain = 'clear-parameter-list-domain',\r\n\r\n    // Creates or edits parameter from intermediate state. Takes a few properties that are cached in dialog and applies them pre-commit.\r\n    CommitParameterEdits = 'commit-parameter-edits',\r\n\r\n    // Gets the model for a particular parameter or returns an empty response if one is not found.\r\n    FindParameterModel = 'find-parameter-model',\r\n\r\n    // Gets the pres model for the show data dialog\r\n    GetShowDataPresModel = 'get-show-data-pres-model',\r\n\r\n    // Export underlying data from the ShowDataDialog to a CSV file\r\n    ShowDataExportToCSV = 'show-data-export-to-csv',\r\n\r\n    // Gets the summary data for a worksheet\r\n    GetSummaryData = 'get-summary-data',\r\n\r\n    // Gets the underlying data for a worksheet\r\n    GetUnderlyingData = 'get-underlying-data',\r\n\r\n    // Gets the underlying data for a specific data source.\r\n    GetDataSourceData = 'get-data-source-data',\r\n\r\n    // Select all marks that have the tuple's value for the given field .\r\n    SelectByTupleValue = 'select-by-tuple-value',\r\n\r\n    // Clear all the selected marks for the given worksheet\r\n    ClearSelectedMarks = 'clear-selected-marks',\r\n\r\n    // Creates or updates and existing filter based on the provided updates.\r\n    ApplyCategoricalFilterUpdates = 'apply-categorical-filter-updates',\r\n\r\n    // Search filter domain for text and return any matching tuples.\r\n    CategoricalFilterSearch = 'categorical-filter-search',\r\n\r\n    // Clear all members from the table of the identified cache.\r\n    CategoricalFilterClearRelationalCache = 'categorical-filter-clear-relational-cache',\r\n\r\n    // Create tuples for an existing filter from supplied text.\r\n    GetCategoricalFilterTuplesFromText = 'get-categorical-filter-tuples-from-text',\r\n\r\n    // Returns a presmodel backing a categorical filter, initializing a data cache for fast lookup of the filter's member domain.\r\n    GetCategoricalFilter = 'get-categorical-filter',\r\n\r\n    // Retrieves a page of data to display in the filter's list domain\r\n    GetCategoricalFilterDomainPage = 'get-categorical-filter-domain-page',\r\n\r\n    // Reset filter to committed state\r\n    ResetCategoricalFilterDeferred = 'reset-categorical-filter-deferred',\r\n\r\n    // Use uncommitted state to reset the filter's controller\r\n    RecreateCategoricalFilterController = 'recreate-categorical-filter-controller',\r\n\r\n    // Validates a Categroical Filter name.\r\n    ValidateCategoricalFilterName = 'validate-categorical-filter-name',\r\n\r\n    // Retrieves the field aggregations allowed for the field being filtered.\r\n    GetFilterFieldAggregations = 'get-filter-field-aggregations',\r\n\r\n    // Gets a summary of the filter pattern.\r\n    GetCategoricalFilterPatternSummary = 'get-categorical-filter-pattern-summary',\r\n\r\n    // Gets a summery of the filter condition.\r\n    GetCategoricalFilterConditionSummary = 'get-categorical-filter-condition-summary',\r\n\r\n    // Load the current minimum and maximum data value range for the condition field.\r\n    LoadCategoricalFilterConditionFieldValueRange = 'load-categorical-filter-condition-field-value-range',\r\n\r\n    // Validates a Categorical Filter's condition formula and re-writes it.\r\n    ValidateCategoricalFilterConditionFormula = 'validate-categorical-filter-condition-formula',\r\n\r\n    // Gets a summery of the filter limit.\r\n    GetCategoricalFilterLimitSummary = 'get-categorical-filter-limit-summary',\r\n\r\n    // Validates a Categorical Filter's limit count.\r\n    ValidateCategoricalFilterLimitCount = 'validate-categorical-filter-limit-count',\r\n\r\n    // Validates a Categorical Filter's limit formula, and re-writes the formula.\r\n    ValidateCategoricalFilterLimitFormula = 'validate-categorical-filter-limit-formula',\r\n\r\n    // Validates a Categorical Filter's limit.\r\n    ValidateCategoricalFilterLimit = 'validate-categorical-filter-limit',\r\n\r\n    // Inform cache when a user changes the range\r\n    CategoricalFilterSetRangeTypeDeferred = 'categorical-filter-set-range-type-deferred',\r\n\r\n    // Inform cache when a user changes whether the selection is exclusive\r\n    CategoricalFilterSetSelectionExclusiveDeferred = 'categorical-filter-set-selection-exclusive-deferred',\r\n\r\n    // Inform cache when a user changes whether an empty selection should be considered a selection of 'All' in a Manual selection mode\r\n    CategoricalFilterSetUseAllWhenManualIsEmptyDeferred = 'categorical-filter-set-use-all-when-manual-is-empty-deferred',\r\n\r\n    // Inform cache when a user alters the preset type\r\n    CategoricalFilterSetPresetTypeDeferred = 'categorical-filter-set-preset-type-deferred',\r\n\r\n    // Inform cache the user has selected one or more members\r\n    CategoricalFilterSelectRelationalMembersDeferred = 'categorical-filter-select-relational-members-deferred',\r\n\r\n    // Inform cache the user has deselected one or more members\r\n    CategoricalFilterDeselectRelationalMembersDeferred = 'categorical-filter-deselect-relational-members-deferred',\r\n\r\n    // Inform cache when a user selects everything in the domain\r\n    CategoricalFilterSelectAllRelationalMembersDeferred = 'categorical-filter-select-all-relational-members-deferred',\r\n\r\n    // Inform cache when a user deselects everything in the domain\r\n    CategoricalFilterDeselectAllRelationalMembersDeferred = 'categorical-filter-deselect-all-relational-members-deferred',\r\n\r\n    // Inform cache the user wants to see a different domain (e.g. relevant values only)\r\n    CategoricalFilterSetDomainTypeDeferred = 'categorical-filter-set-domain-type-deferred',\r\n\r\n    // Set whether filters apply to totals as well as non-totals table calcs\r\n    FilterApplyToTotalTableCalcs = 'filter-apply-to-total-table-calcs',\r\n\r\n    // Gets the list of filters used in a worksheet\r\n    GetWorksheetFilters = 'get-worksheet-filters',\r\n\r\n    // Gets the domain for a categorical Filter\r\n    GetCategoricalDomain = 'get-categorical-domain',\r\n\r\n    // Gets the domain for a quantitative Filter\r\n    GetQuantitativeDomain = 'get-quantitative-domain',\r\n\r\n    // Creates a datasource filter store and returns a list of the current datasource filters.\r\n    CreateDatasourceFilterStore = 'create-datasource-filter-store',\r\n\r\n    // Commits the pending datasource filter changes in the filter store.\r\n    CommitDatasourceFilterStore = 'commit-datasource-filter-store',\r\n\r\n    // Gets the list of datasource fields that can be filtered.\r\n    GetDatasourceFilterFieldPickerModel = 'get-datasource-filter-field-picker-model',\r\n\r\n    // Get field information needed for creating a datasource filter.\r\n    GetDatasourceFilterFieldInfo = 'get-datasource-filter-field-info',\r\n\r\n    // Gets a filter presentation model form a filter store.\r\n    GetFilterFromStore = 'get-filter-from-store',\r\n\r\n    // Removes a filter from a filter store.\r\n    RemoveFilterFromStore = 'remove-filter-from-store',\r\n\r\n    // Releases a filter store, and its resources, once it is no longer needed.\r\n    ReleaseFilterStore = 'release-filter-store',\r\n\r\n\r\n    // \r\n    GetHighlightedData = 'get-highlighted-data',\r\n\r\n    // \r\n    GetSelectionData = 'get-selection',\r\n\r\n    // \r\n    Select = 'select',\r\n\r\n    // \r\n    SelectAll = 'select-all',\r\n\r\n    // \r\n    SelectByValue = 'select-by-value',\r\n\r\n    // \r\n    SelectNoneIncludingMaster = 'select-none-including-master',\r\n\r\n    // \r\n    AddManualItemsToFilter = 'add-manual-items-to-filter',\r\n\r\n    // \r\n    CategoricalFilter = 'categorical-filter',\r\n\r\n    // \r\n    CategoricalFilterByIndex = 'categorical-filter-by-index',\r\n\r\n    // \r\n    ChangeSharedFilter = 'change-shared-filter',\r\n\r\n    // \r\n    ClearContextFilters = 'clear-context-filters',\r\n\r\n    // \r\n    ClearExistingFilter = 'clear-existing-filter',\r\n\r\n    // \r\n    DefaultFilter = 'default-filter',\r\n\r\n    // \r\n    FilterGeo = 'filter-geo',\r\n\r\n    // \r\n    FilterNeg = 'filter-neg',\r\n\r\n    // \r\n    FilterNulls = 'filter-nulls',\r\n\r\n    // \r\n    FilterTargets = 'filter-targets',\r\n\r\n    // \r\n    GetSharedFilterPresModel = 'get-shared-filter-pres-model',\r\n\r\n    // \r\n    HierarchicalFilter = 'hierarchical-filter',\r\n\r\n    // \r\n    KeepOnlyOrExclude = 'keep-only-or-exclude',\r\n\r\n    // \r\n    RangeFilter = 'range-filter',\r\n\r\n    // \r\n    RelDateFilter = 'relative-date-filter',\r\n\r\n    // \r\n    ResetFilter = 'reset-filter',\r\n\r\n    // \r\n    ShowGeoAtDefault = 'show-geo-at-default',\r\n\r\n    // \r\n    ShowSVAtDefault = 'show-sv-at-default',\r\n\r\n    // \r\n    ToggleLockQuickFilters = 'toggle-lock-quick-filters',\r\n\r\n    // \r\n    AddDataConnection = 'add-data-connection',\r\n\r\n    // \r\n    AddDrillPath = 'add-drill-path',\r\n\r\n    // \r\n    AddCredentialsFromKeychain = 'add-credentials-from-keychain',\r\n\r\n    // \r\n    AddCredentialsFromKeychainFile = 'add-credentials-from-keychain-file',\r\n\r\n    // \r\n    AddFieldFolder = 'add-field-folder',\r\n\r\n    // \r\n    AddSubtotals = 'add-subtotals',\r\n\r\n    // \r\n    AddToDrillPath = 'add-to-drill-path',\r\n\r\n    // \r\n    AddToFieldFolder = 'add-to-field-folder',\r\n\r\n    // \r\n    AggregateMeasuresFlag = 'aggregate-measures',\r\n\r\n    // \r\n    ApplyCalculation = 'apply-calculation',\r\n\r\n    // \r\n    ApplyPageSetupOptions = 'apply-page-setup-options',\r\n\r\n    // \r\n    ApplyTableOptions = 'apply-table-options',\r\n\r\n    // \r\n    ApplyTypeInPill = 'apply-type-in-pill',\r\n\r\n    // \r\n    Assert = 'assert',\r\n\r\n    // \r\n    AttemptConnectDataSourcesOnSheet = 'attempt-connect-datasources-on-sheet',\r\n\r\n    // \r\n    AttemptConnectWorkbook = 'attempt-connect-workbook',\r\n\r\n    // \r\n    AttemptDataSourcesConnection = 'attempt-datasources-connection',\r\n\r\n    // \r\n    AutoUpdates = 'auto-update',\r\n\r\n    // \r\n    Brush = 'highlight',\r\n\r\n    // \r\n    BrushSpecial = 'highlight-special',\r\n\r\n    // \r\n    BuildDataSchemaDataSourceContextMenu = 'build-data-schema-data-source-context-menu',\r\n\r\n    // \r\n    BuildDataSchemaContextMenu = 'build-data-schema-context-menu',\r\n\r\n    // \r\n    BuildDataSchemaFieldContextMenu = 'build-data-schema-field-context-menu',\r\n\r\n    // \r\n    BuildDataSchemaDrillPathContextMenu = 'build-data-schema-drill-path-context-menu',\r\n\r\n    // \r\n    BuildFileTableInfoPresModel = 'build-file-table-info-pres-model',\r\n\r\n    // \r\n    BuildSheetTabContextMenu = 'build-sheet-tab-context-menu',\r\n\r\n    // \r\n    CancelDataSourcePresModel = 'cancel-datasource-pres-model',\r\n\r\n    // \r\n    CatBinMergeSplitLabel = 'categorical-bin-merge-split',\r\n\r\n    // \r\n    CategoricalQuickFilterEdit = 'categorical-quick-filter-edit',\r\n\r\n    // \r\n    CategoricalQuickFilterExcludeValues = 'categorical-quick-filter-exclude-values',\r\n\r\n    // \r\n    CategoricalQuickFilterIncludeAllWhenEmpty = 'categorical-quick-filter-include-all-when-empty',\r\n\r\n    // \r\n    CategoricalQuickFilterMode = 'categorical-quick-filter-mode',\r\n\r\n    // \r\n    CategoricalQuickFilterPattern = 'categorical-quick-filter-pattern',\r\n\r\n    // \r\n    ChangeAggregation = 'change-aggregation',\r\n\r\n    // \r\n    ChangeAlphaLevel = 'change-alpha-level',\r\n\r\n    // \r\n    ChangeBorder = 'change-border',\r\n\r\n    // \r\n    ChangeFieldType = 'change-field-type',\r\n\r\n    // \r\n    ChangeForecastColumnType = 'change-forecast-column-type',\r\n\r\n    // \r\n    ChangeHalo = 'change-halo',\r\n\r\n    // \r\n    ChangeMarkers = 'change-markers',\r\n\r\n    // \r\n    ChangeSize = 'change-size',\r\n\r\n    // \r\n    ChangeSheetTabColor = 'change-sheet-tab-color',\r\n\r\n    // \r\n    ClearAllAxisRanges = 'clear-axis-ranges',\r\n\r\n    // \r\n    ClearCalcModel = 'clear-calculation-model',\r\n\r\n    // \r\n    ClearFilters = 'clear-filters',\r\n\r\n    // \r\n    ClearFormatting = 'clear-formatting',\r\n\r\n    // \r\n    ClearFuture = 'clear-future',\r\n\r\n    // \r\n    ClearLayout = 'clear-layout',\r\n\r\n    // \r\n    ClearQuickFilter = 'clear-quick-filter',\r\n\r\n    // \r\n    ClearSorts = 'clear-sorts',\r\n\r\n    // \r\n    CloseConnection = 'close-connection',\r\n\r\n    // \r\n    CloseDataSource = 'close-data-source',\r\n\r\n    // \r\n    ConnectionAddGoogleAnalyticsDimension = 'connection-add-google-analytics-dimension',\r\n\r\n    // \r\n    ConnectionAddGoogleAnalyticsMeasure = 'connection-add-google-analytics-measure',\r\n\r\n    // \r\n    ConnectionAddNewTable = 'connection-add-new-table',\r\n\r\n    // \r\n    ConnectionAddCoalesce = 'connection-add-coalesce',\r\n\r\n    // \r\n    ConnectionAddPivot = 'connection-add-pivot',\r\n\r\n    // \r\n    ConnectionConvertToUnionAndEdit = 'connection-convert-to-union-and-edit',\r\n\r\n    // \r\n    ConnectionConvertToUnion = 'connection-convert-to-union',\r\n\r\n    // \r\n    ConnectionEditUnion = 'connection-edit-union',\r\n\r\n    // \r\n    ConnectionAddOrEditBatchUnion = 'connection-add-or-edit-batch-union',\r\n\r\n    // \r\n    ConnectionChangeTableProperty = 'connection-change-table-property',\r\n\r\n    // \r\n    ConnectionCountEntity = 'connection-count-entity',\r\n\r\n    // \r\n    ConnectionDataServerFetchMoreDatasources = 'connection-dataserver-fetch-more-datasources',\r\n\r\n    // \r\n    ConnectionDataServerProjectSelect = 'connection-dataserver-change-selected-project',\r\n\r\n    // \r\n    ConnectionDataServerUpdateFetchParameters = 'connection-dataserver-update-fetch-parameters',\r\n\r\n    // \r\n    ConnectionDataServerFlushCache = 'connection-dataserver-flush-cache',\r\n\r\n    // \r\n    ConnectionDeleteAllTables = 'connection-delete-all-tables',\r\n\r\n    // \r\n    ConnectionDeleteTable = 'connection-delete-table',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsAccount = 'connection-edit-google-analytics-account',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsDateRange = 'connection-edit-google-analytics-date-range',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsMeasureGroup = 'connection-edit-google-analytics-measure-group',\r\n\r\n    // \r\n    ConnectionToggleGAQueryPartitioning = 'connection-toggle-ga-query-partitioning',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsProperty = 'connection-edit-google-analytics-property',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsView = 'connection-edit-google-analytics-view',\r\n\r\n    // \r\n    ConnectionEditGoogleAnalyticsSegment = 'connection-edit-google-analytics-segment',\r\n\r\n    // \r\n    ConnectionEditJoinClauses = 'connection-edit-join-clauses',\r\n\r\n    // \r\n    ConnectionEditJoinType = 'connection-edit-join-type',\r\n\r\n    // \r\n    ConnectionEditSQLText = 'connection-edit-sql-text',\r\n\r\n    // \r\n    ConnectionFetchEntity = 'connection-fetch-entity',\r\n\r\n    // \r\n    ConnectionSetForceExtractRefresh = 'connection-set-force-extract-refresh',\r\n\r\n    // \r\n    ConnectionPrepareDataSourceForEdit = 'connection-prepare-datasource-for-edit',\r\n\r\n    // \r\n    ConnectionClearRefreshAttributes = 'connection-clear-refresh-attributes',\r\n\r\n    // \r\n    ConnectionRemoveGoogleAnalyticsDimension = 'connection-remove-google-analytics-dimension',\r\n\r\n    // \r\n    ConnectionRemoveGoogleAnalyticsMeasure = 'connection-remove-google-analytics-measure',\r\n\r\n    // \r\n    ConnectionRemoveCoalesce = 'connection-remove-coalesce',\r\n\r\n    // \r\n    ConnectionRemovePivot = 'connection-remove-pivot',\r\n\r\n    // \r\n    ConnectionAddDateParseFormats = 'connection-add-date-parse-formats',\r\n\r\n    // \r\n    ConnectionRenameTable = 'connection-rename-table',\r\n\r\n    // \r\n    ConnectionReplaceRelationWithSQLText = 'connection-replace-relation-with-sql-text',\r\n\r\n    // \r\n    ConnectionReplaceTable = 'connection-replace-table',\r\n\r\n    // \r\n    ConnectionResetTableAlias = 'connection-reset-table-alias',\r\n\r\n    // \r\n    ConnectionSelectCatalog = 'connection-select-catalog',\r\n\r\n    // \r\n    ConnectionSelectCube = 'connection-select-cube',\r\n\r\n    // \r\n    ConnectionSelectStoredProcedure = 'connection-select-stored-procedure',\r\n\r\n    // \r\n    ConnectionSelectBigQueryLegacySQLCheckBox = 'connection-select-bigquery-legacy-check',\r\n\r\n    // \r\n    ConnectionToggleHasHeaderRow = 'connection-toggle-has-header-row',\r\n\r\n    // \r\n    ConnectionToggleTableCleaning = 'connection-toggle-table-cleaning',\r\n\r\n    // \r\n    ConnectionToggleUseExtract = 'connection-toggle-use-extract',\r\n\r\n    // \r\n    ConnectionViewTableCleaningResults = 'connection-view-table-cleaning-results',\r\n\r\n    // \r\n    ConnectToDataServerSource = 'connect-data-server-datasource',\r\n\r\n    // \r\n    ConsiderZerosEmptyFlag = 'consider-zeros-empty',\r\n\r\n    // \r\n    ConvertUnnamedFields = 'convert-unnamed-fields',\r\n\r\n    // \r\n    Crash = 'crash',\r\n\r\n    // \r\n    CreateAggregateRole = 'create-aggregate-role',\r\n\r\n    // \r\n    CreateConnection = 'create-connection',\r\n\r\n    // \r\n    CreateDefaultQuickFilter = 'create-default-quick-filter',\r\n\r\n    // \r\n    CreateTypeInPill = 'create-type-in-pill',\r\n\r\n    // \r\n    CustomDataGridFieldOrder = 'custom-datagrid-field-order',\r\n\r\n    // \r\n    CustomDateAggregation = 'custom-date-aggregation',\r\n\r\n    // \r\n    CustomSplitField = 'custom-split-field',\r\n\r\n    // \r\n    DebugAssertion = 'debug-assertion',\r\n\r\n    // \r\n    DecrementParameterValue = 'decr-parameter-value',\r\n\r\n    // \r\n    DeleteFields = 'delete-calculation-fields-command',\r\n\r\n    // \r\n    DeleteSheet = 'delete-sheet',\r\n\r\n    // \r\n    DescribeDrillPath = 'describe-drill-path',\r\n\r\n    // \r\n    DescribeSortFilter = 'describe-sort-filter',\r\n\r\n    // \r\n    DismissNullWart = 'dismiss-null-wart',\r\n\r\n    // \r\n    DomainQuickFilter = 'domain-quick-filter',\r\n\r\n    // \r\n    DoubleFreeCrash = 'double-free',\r\n\r\n    // \r\n    DropNowhere = 'drop-nowhere',\r\n\r\n    // \r\n    DropOnSchemaViewer = 'drop-on-schema-viewer',\r\n\r\n    // \r\n    DropOnShelf = 'drop-on-shelf',\r\n\r\n    // \r\n    DropOnCalcEditor = 'drop-on-calc-editor',\r\n\r\n    // \r\n    DropOnShowMe = 'drop-on-showme',\r\n\r\n    // \r\n    DropPrepare = 'drop-prepare',\r\n\r\n    // \r\n    DualAxis = 'dual-axis',\r\n\r\n    // \r\n    DuplicateSheet = 'duplicate-sheet',\r\n\r\n    // \r\n    EditCopyCalc = 'edit-copy-calc',\r\n\r\n    // \r\n    EditDropLines = 'edit-drop-lines',\r\n\r\n    // \r\n    EditEnumeratedGroup = 'edit-enumerated-group',\r\n\r\n    // \r\n    EditNestedGroup = 'edit-nested-group',\r\n\r\n    // \r\n    EditPill = 'edit-pill',\r\n\r\n    // \r\n    EditPrimitiveType = 'edit-primitive-type',\r\n\r\n    // \r\n    EnableAllBrushing = 'enable-all-highlights',\r\n\r\n    // \r\n    EnableQuickFilter = 'enable-quick-filter',\r\n\r\n    // \r\n    EnableSheetBrushing = 'enable-sheet-highlights',\r\n\r\n    // \r\n    EnableThemedBrushing = 'enable-themed-highlights',\r\n\r\n    // \r\n    EnumerateVariables = 'enumerate-variables',\r\n\r\n    // \r\n    EnumerateVariableSelectionValues = 'enumerate-variable-selection-values',\r\n\r\n    // \r\n    EstablishConnection = 'establish-connection',\r\n\r\n    // \r\n    EstablishMatchingConnections = 'establish-matching-connections',\r\n\r\n    // \r\n    ExportDataToText = 'export-data-to-text',\r\n\r\n    // \r\n    ExtSvcConfig = 'ext-svc-config',\r\n\r\n    // \r\n    ExtSvcConfigConnect = 'ext-svc-config-connect',\r\n\r\n    // \r\n    Extract = 'extract',\r\n\r\n    // \r\n    SetDataGridCurrentTable = 'set-data-grid-current-table',\r\n\r\n    // \r\n    FetchTableRelevance = 'fetch-table-relevance',\r\n\r\n    // \r\n    FetchCachedTableRelevance = 'fetch-cached-table-relevance',\r\n\r\n    // \r\n    FlipLabels = 'flip-labels',\r\n\r\n    // \r\n    FloatingToolbar = 'zoom-controls',\r\n\r\n    // \r\n    FloatingToolbarToggle = 'zoom-controls-toggle',\r\n\r\n    // \r\n    ForecastConfig = 'forecast-config',\r\n\r\n    // \r\n    ForecastToggle = 'forecast-toggle',\r\n\r\n    // \r\n    FormatWorkbook = 'format-workbook',\r\n\r\n    // \r\n    GeographicSearchQuery = 'geographic-search-query',\r\n\r\n    // \r\n    GeographicSearchLoadData = 'geographic-search-load-data',\r\n\r\n    // \r\n    GeographicSearchIsDataDoneLoading = 'geographic-search-data-done-loading',\r\n\r\n    // \r\n    GeographicSearchToggleVisibility = 'geographic-search-toggle-visibility',\r\n\r\n    // \r\n    GetEditConnectionPresModel = 'get-edit-connection-pres-model',\r\n\r\n    // \r\n    GetEditEnumeratedGroupPresModel = 'get-edit-enumerated-group-pres-model',\r\n\r\n    // \r\n    GetEditNestedGroupPresModel = 'get-edit-nested-group-pres-model',\r\n\r\n    // \r\n    GetFrameFinderPresModel = 'get-frame-finder-pres-model',\r\n\r\n    // \r\n    GetGoogleSheetsListPresModel = 'get-google-sheets-list-pres-model',\r\n\r\n    // \r\n    GetGoogleSheetPanePresModel = 'get-google-sheet-pane-pres-model',\r\n\r\n    // \r\n    GetInitialSQLPresModel = 'get-initial-sql-pres-model',\r\n\r\n    // \r\n    GetQueryBandingPresModel = 'get-query-banding-pres-model',\r\n\r\n    // \r\n    GetTabbedAuthenticationPresModel = 'get-tabbed-authentication-pres-model',\r\n\r\n    // \r\n    GetActiveSheet = 'get-active-sheet',\r\n\r\n    // \r\n    GetAlphaLevel = 'get-alpha-level',\r\n\r\n    // \r\n    GetAppConfig = 'get-app-config',\r\n\r\n    // \r\n    GetDisabledSecondaryDSFields = 'get-disabled-secondaryds-fields',\r\n\r\n    // \r\n    GetBlendingFields = 'get-blending-fields',\r\n\r\n    // \r\n    GetCalculationPresModel = 'get-calculation-pres-model',\r\n\r\n    // \r\n    GetCategoricalColor = 'get-categorical-color',\r\n\r\n    // \r\n    GetClientInfo = 'get-client-info',\r\n\r\n    // \r\n    GetCommands = 'get-commands',\r\n\r\n    // \r\n    GetConnectionDescriptionPresModel = 'get-connection-description-pres-model',\r\n\r\n    // \r\n    GetDSDropdownPresModel = 'get-ds-dropdown-pres-model',\r\n\r\n    // \r\n    GetDataPreviewWindowMessagePresModel = 'get-data-preview-window-pres-model',\r\n\r\n    // \r\n    GetDataSourcePresModel = 'get-datasource-pres-model',\r\n\r\n    // \r\n    GetDataSourceSortPresModel = 'get-datasource-sort-pres-model',\r\n\r\n    // \r\n    GetDataSourcePropertiesPresModel = 'get-datasource-properties-pres-model',\r\n\r\n    // \r\n    GetConnectionSettingsPresModel = 'get-connection-settings-pres-model',\r\n\r\n    // \r\n    GetDashboard = 'get-dashboard',\r\n\r\n    // \r\n    GetDataPreview = 'get-data-preview',\r\n\r\n    // \r\n    GetDatabaseEnumerationPresModel = 'get-database-enumeration-pres-model',\r\n\r\n    // \r\n    GetDefaultColor = 'get-default-color',\r\n\r\n    // \r\n    GetDefaultShape = 'get-default-shape',\r\n\r\n    // \r\n    GetDragPresModelForText = 'get-drag-pres-model-for-text',\r\n\r\n    // \r\n    GetDropTargetPresModel = 'get-drop-target-pres-model',\r\n\r\n    // \r\n    GetEditDataServerConnectionPresModel = 'get-edit-data-server-connection-pres-model',\r\n\r\n    // \r\n    GetEditDropLinesModel = 'get-edit-drop-lines-model',\r\n\r\n    // \r\n    GetEncodingState = 'get-encoding-state',\r\n\r\n    // \r\n    GetEncodingTypeMenuModel = 'get-encoding-type-menu',\r\n\r\n    // \r\n    GetExtSvcConfig = 'get-ext-svc-config',\r\n\r\n    // \r\n    GetForecastPresModel = 'get-forecast-pres-model',\r\n\r\n    // \r\n    GetJoinDescriptionPresModel = 'get-join-description-pres-model',\r\n\r\n    // \r\n    GetQuickFilter = 'get-quick-filter',\r\n\r\n    // \r\n    GetQuickFilters = 'get-quick-filters',\r\n\r\n    // \r\n    GetReferenceLinePresModel = 'get-reference-line-pres-model',\r\n\r\n    // \r\n    GetParameters = 'get-parameters',\r\n\r\n    // \r\n    GetParameterModels = 'get-parameter-models',\r\n\r\n    // \r\n    GetParametersRegistryInfo = 'get-params-registry-info',\r\n\r\n    // \r\n    GetPivotPresModel = 'get-pivot-pres-model',\r\n\r\n    // \r\n    GetScene = 'get-scene',\r\n\r\n    // \r\n    GetSchemaEnumerationPresModel = 'get-schema-enumeration-pres-model',\r\n\r\n    // \r\n    GetSheetsInfo = 'get-sheets-info',\r\n\r\n    // \r\n    GetShowMe = 'get-show-me',\r\n\r\n    // \r\n    GetStandardConnectionEnumerationPresModel = 'get-standard-connection-enumeration-pres-model',\r\n\r\n    // \r\n    GetStoredProcedureEnumerationPresModel = 'get-stored-procedure-enumeration-pres-model',\r\n\r\n    // \r\n    GetStoredProcedureParametersPresModel = 'get-stored-procedure-parameters-pres-model',\r\n\r\n    // \r\n    GetTableEnumerationPresModel = 'get-table-enumeration-pres-model',\r\n\r\n    // \r\n    GetTableCleaningPresModel = 'get-table-cleaning-pres-model',\r\n\r\n    // \r\n    GetTargetFieldList = 'get-target-field-list',\r\n\r\n    // \r\n    GetTopLevelConnectionDescriptionPresModel = 'get-top-level-connection-description-pres-model',\r\n\r\n    // \r\n    GetTypeInPillPresModel = 'get-type-in-pill-pres-model',\r\n\r\n    // \r\n    GetUberTipPresModel = 'get-ubertip-pres-model',\r\n\r\n    // \r\n    GetUnionInfoPresModel = 'get-union-info-pres-model',\r\n\r\n    // \r\n    GetVisual = 'get-visual',\r\n\r\n    // \r\n    GetVizData = 'get-viz-data',\r\n\r\n    // \r\n    GetWarehouseEnumerationPresModel = 'get-warehouse-enumeration-pres-model',\r\n\r\n    // \r\n    GetWorkbook = 'get-workbook',\r\n\r\n    // \r\n    GetWorldUpdate = 'get-world-update',\r\n\r\n    // \r\n    GoToSheet = 'goto-sheet',\r\n\r\n    // \r\n    HeapCorruptionCrash = 'corrupt-heap',\r\n\r\n    // \r\n    HideColumnFieldLabel = 'hide-column-field-label',\r\n\r\n    // \r\n    HideEmptyColsFlag = 'hide-empty-cols',\r\n\r\n    // \r\n    HideEmptyRowsFlag = 'hide-empty-rows',\r\n\r\n    // \r\n    HideLabel = 'hide-label',\r\n\r\n    // \r\n    HideRowFieldLabel = 'hide-row-field-label',\r\n\r\n    // \r\n    HierarchicalQuickFilterUpdateSetFunction = 'hierarchical-quick-filter-update-set-function',\r\n\r\n    // \r\n    IncludeInTooltip = 'include-in-tooltip',\r\n\r\n    // \r\n    IncludeOtherCategoricalBin = 'include-other-cat-bin',\r\n\r\n    // \r\n    IncrementExtract = 'increment-extract',\r\n\r\n    // \r\n    IncrementParameterValue = 'incr-parameter-value',\r\n\r\n    // \r\n    CreateCalc = 'create-calc',\r\n\r\n    // \r\n    EditCalc = 'edit-calc',\r\n\r\n    // \r\n    InvokeHyperlink = 'invoke-hyperlink',\r\n\r\n    // \r\n    KeepOnlyOrExcludeSelection = 'keep-only-or-exclude-selection',\r\n\r\n    // \r\n    LabelDrill = 'label-drill',\r\n\r\n    // \r\n    LabelDrillCtx = 'label-drill-ctx',\r\n\r\n    // \r\n    LevelDrill = 'level-drill',\r\n\r\n    // \r\n    LoadUrl = 'load-url',\r\n\r\n    // \r\n    ListPublishedDataSources = 'list-published-datasources',\r\n\r\n    // \r\n    MarkLabel = 'mark-label',\r\n\r\n    // \r\n    MarkTrail = 'mark-trail',\r\n\r\n    // \r\n    MemoryDumpObjectCounts = 'memory-dump-object-counts',\r\n\r\n    // \r\n    MemoryLeak = 'memory-leak',\r\n\r\n    // \r\n    Merge = 'merge-or-split',\r\n\r\n    // \r\n    MigrateDataSource = 'migrate-data-source',\r\n\r\n    // \r\n    ModifyMarksInSet = 'add-or-remove-marks',\r\n\r\n    // \r\n    MoveAreaAnnotationText = 'move-area-annotation-text',\r\n\r\n    // \r\n    MoveColumnTotals = 'move-column-totals',\r\n\r\n    // \r\n    MoveMark = 'move-mark',\r\n\r\n    // \r\n    MovePointAnnotation = 'move-point-annotation',\r\n\r\n    // \r\n    MovePointAnnotationTarget = 'move-point-annotation-target',\r\n\r\n    // \r\n    MoveReferenceLine = 'move-reference-line',\r\n\r\n    // \r\n    MoveRowTotals = 'move-row-totals',\r\n\r\n    // \r\n    NavigateToSheet = 'navigate-to-sheet',\r\n\r\n    // \r\n    PostCalcJoinClauseResult = 'post-calc-join-clause-result',\r\n\r\n    // \r\n    NewDocDashboard = 'new-dashboard',\r\n\r\n    // \r\n    NewDocWorksheet = 'new-worksheet',\r\n\r\n    // \r\n    NonRangedRemoveReferenceLine = 'non-ranged-remove-reference-line',\r\n\r\n    // \r\n    OptimizeExtract = 'optimize-extract',\r\n\r\n    // \r\n    OptOutActions = 'opt-out-actions',\r\n\r\n    // \r\n    PageHistorySettings = 'page-history-settings',\r\n\r\n    // \r\n    PageToggleTrails = 'page-toggle-trails',\r\n\r\n    // \r\n    ParseUIName = 'parse-ui-name',\r\n\r\n    // \r\n    Percentages = 'percentages',\r\n\r\n    // \r\n    Perspectives = 'perspectives',\r\n\r\n    // \r\n    PositionPointAnnotation = 'position-point-annotation',\r\n\r\n    // \r\n    ProtocolPoolLog = 'protocol-pool-log',\r\n\r\n    // \r\n    PublishToWorkgroup = 'publish-to-workgroup',\r\n\r\n    // \r\n    PublishDataSource = 'publish-datasource',\r\n\r\n    // \r\n    PublishDataSourceFromData = 'publish-data-source-from-data',\r\n\r\n    // \r\n    PublishDataSourceFromWorkbookData = 'publish-data-source-from-workbook-data',\r\n\r\n    // \r\n    QuantitativeQuickFilterEdit = 'quantitative-quick-filter-edit',\r\n\r\n    // \r\n    QuantitativeModeQuickFilter = 'quantitative-mode-quick-filter',\r\n\r\n    // \r\n    QueryMigrateDataSources = 'query-migrate-data-sources',\r\n\r\n    // \r\n    QuickSort = 'quick-sort',\r\n\r\n    // \r\n    RangedByIndexMerge = 'ranged-by-index-merge',\r\n\r\n    // \r\n    RangedByValueMerge = 'ranged-by-value-merge',\r\n\r\n    // \r\n    Record = 'record',\r\n\r\n    // \r\n    Redo = 'redo',\r\n\r\n    // \r\n    RefreshExtract = 'refresh-extract',\r\n\r\n    // \r\n    RefreshFromSource = 'refresh-from-source',\r\n\r\n    // \r\n    RelativeDateQuickFilterEdit = 'relative-date-quick-filter-edit',\r\n\r\n    // \r\n    RemoveAllReferenceLines = 'remove-all-reference-lines',\r\n\r\n    // \r\n    RemoveDrillPath = 'remove-drill-path',\r\n\r\n    // \r\n    RemoveExtract = 'remove-extract',\r\n\r\n    // \r\n    RemoveFieldFolder = 'remove-field-folder',\r\n\r\n    // \r\n    RemoveFieldLabel = 'remove-field-label',\r\n\r\n    // \r\n    RemoveFields = 'remove-fields',\r\n\r\n    // \r\n    RemoveFieldsFromShelf = 'remove-fields-from-shelf',\r\n\r\n    // \r\n    RemoveFromDrillPath = 'remove-from-drill-path',\r\n\r\n    // \r\n    RemoveFromFieldFolder = 'remove-from-field-folder',\r\n\r\n    // \r\n    RemoveReferenceLine = 'remove-reference-line',\r\n\r\n    // \r\n    RemoveSubtotals = 'remove-subtotals',\r\n\r\n    // \r\n    RenameDataSource = 'rename-data-source',\r\n\r\n    // \r\n    RenameDrillPath = 'rename-drill-path',\r\n\r\n    // \r\n    RenameFieldFolder = 'rename-field-folder',\r\n\r\n    // \r\n    RenameSheet = 'rename-sheet',\r\n\r\n    // \r\n    ReorderLabels = 'reorder-labels',\r\n\r\n    // \r\n    ReportBug = 'report-bug',\r\n\r\n    // \r\n    RequestDataSourcePresModel = 'request-datasource-pres-model',\r\n\r\n    // \r\n    ResetParameterCtrlTitle = 'reset-parameter-ctrl-title',\r\n\r\n    // \r\n    ResetTooltip = 'reset-tooltip',\r\n\r\n    // \r\n    ResizeAreaAnnotationText = 'resize-area-annotation-text',\r\n\r\n    // \r\n    ResizeAxis = 'resize-axis',\r\n\r\n    // \r\n    ResizeCell = 'resize-cell',\r\n\r\n    // \r\n    ResizeHeader = 'resize-header',\r\n\r\n    // \r\n    ResizePointAnnotation = 'resize-point-annotation',\r\n\r\n    // \r\n    Revert = 'revert',\r\n\r\n    // \r\n    RotateFieldLabel = 'rotate-field-label',\r\n\r\n    // \r\n    RotateLabel = 'rotate-label',\r\n\r\n    // \r\n    SplitFieldLabel = 'split-field-label',\r\n\r\n    // \r\n    RunAction = 'run-action',\r\n\r\n    // \r\n    RunScript = 'run-script',\r\n\r\n    // \r\n    RunUpdates = 'run-update',\r\n\r\n    // \r\n    SaveModel = 'save-model',\r\n\r\n    // \r\n    SavePublishedDStoFile = 'save-published-ds-to-file',\r\n\r\n    // \r\n    SelectDataSource = 'select-data-source',\r\n\r\n    // \r\n    SelectFieldsInShelf = 'select-fields-in-shelf',\r\n\r\n    // \r\n    SendDataConnectionTableViewMessage = 'send-data-connection-tableview-message',\r\n\r\n    // \r\n    SetActiveDataSourceName = 'set-active-data-source-name',\r\n\r\n    // \r\n    SetActiveConnectionName = 'set-active-connection-name',\r\n\r\n    // \r\n    SetActiveDataSource = 'set-active-datasource',\r\n\r\n    // \r\n    SetBasePalette = 'set-base-palette',\r\n\r\n    // \r\n    SetCategoricalColor = 'set-categorical-color',\r\n\r\n    // \r\n    SetDataCacheDelta = 'set-data-cache-delta',\r\n\r\n    // \r\n    SetDataPreviewAutoUpdate = 'set-data-preview-auto-update',\r\n\r\n    // \r\n    SetDataPreviewCustomFieldOrder = 'set-data-preview-custom-field-order',\r\n\r\n    // \r\n    SetDefaultColor = 'set-default-color',\r\n\r\n    // \r\n    SetDefaultShape = 'set-default-shape',\r\n\r\n    // \r\n    SetFilterContext = 'set-filter-context',\r\n\r\n    // \r\n    SetFilterShared = 'set-filter-shared',\r\n\r\n    // \r\n    SetInitialSQL = 'set-initial-sql',\r\n\r\n    // \r\n    SetItemColor = 'set-item-color',\r\n\r\n    // \r\n    SetItemColorResetCustomization = 'set-item-color-reset-customization',\r\n\r\n    // \r\n    SetItemEncodingType = 'set-item-encoding-type',\r\n\r\n    // \r\n    SetMarkSize = 'set-mark-size',\r\n\r\n    // \r\n    SetPageNavFlag = 'set-page-flag',\r\n\r\n    // \r\n    SetParameterCtrlDisplayFlags = 'set-parameter-ctrl-display-flags',\r\n\r\n    // \r\n    SetParameterCtrlDisplayMode = 'set-parameter-ctrl-display-mode',\r\n\r\n    // \r\n    SetParameterCtrlTitle = 'set-parameter-ctrl-title',\r\n\r\n    // \r\n    SetParameterValue = 'set-parameter-value',\r\n\r\n    // \r\n    SetPrimitive = 'set-primitive',\r\n\r\n    // \r\n    SetQueryBanding = 'set-query-banding',\r\n\r\n    // \r\n    SetQuickFilterIncludedValues = 'set-quick-filter-included',\r\n\r\n    // \r\n    SetReferenceLineFormula = 'set-reference-line-formula',\r\n\r\n    // \r\n    SetReferenceLineConstantValue = 'set-reference-line-constant-value',\r\n\r\n    // \r\n    SetSheetFormatting = 'set-sheet-formatting',\r\n\r\n    // \r\n    SetSheetSize = 'set-sheet-size',\r\n\r\n    // \r\n    SetTotalsType = 'set-totals-type',\r\n\r\n    // \r\n    SetWorkbookLocale = 'set-workbook-locale',\r\n\r\n    // \r\n    ShowCatCtrlQuickFilter = 'show-cat-ctrl-quick-filter',\r\n\r\n    // \r\n    ShowColFieldNamesFlag = 'show-col-field-names',\r\n\r\n    // \r\n    ShowColTotalsFlag = 'show-col-totals',\r\n\r\n    // \r\n    ShowColumnFieldLabel = 'show-column-field-label',\r\n\r\n    // \r\n    ShowEmptyColsFlag = 'show-empty-cols',\r\n\r\n    // \r\n    ShowEmptyRowsFlag = 'show-empty-rows',\r\n\r\n    // \r\n    ShowForecastEditor = 'show-forecast-editor',\r\n\r\n    // \r\n    ShowFullRange = 'show-full-range',\r\n\r\n    // \r\n    ShowHeader = 'show-header',\r\n\r\n    // \r\n    ShowHiddenData = 'show-hidden-data',\r\n\r\n    // \r\n    ShowMe = 'show-me',\r\n\r\n    // \r\n    ShowQuantCtrlQuickFilter = 'show-quant-ctrl-quick-filter',\r\n\r\n    // \r\n    ShowQuickFilterDoc = 'show-quickfilter-doc',\r\n\r\n    // \r\n    ShowReferenceLineEditor = 'show-reference-line-editor',\r\n\r\n    // \r\n    ShowReferenceLineConstantValueEditor = 'show-reference-line-constant-value-editor',\r\n\r\n    // \r\n    ShowReferenceLineFormatter = 'show-reference-line-formatter',\r\n\r\n    // \r\n    ShowRowFieldLabel = 'show-row-field-label',\r\n\r\n    // \r\n    ShowRowFieldNamesFlag = 'show-row-field-names',\r\n\r\n    // \r\n    ShowRowTotalsFlag = 'show-row-totals',\r\n\r\n    // \r\n    SimpleCommandList = 'simple-command-list',\r\n\r\n    // \r\n    Sleep = 'sleep',\r\n\r\n    // \r\n    SleepBackgroundThread = 'sleep-background-thread',\r\n\r\n    // \r\n    SortDataGridByColumn = 'sort-datagrid-by-column',\r\n\r\n    // \r\n    SortDataGridFields = 'sort-datagrid-fields',\r\n\r\n    // \r\n    SpecialValues = 'special-values',\r\n\r\n    // \r\n    SplitField = 'split-field',\r\n\r\n    // \r\n    StackMarks = 'stack-marks',\r\n\r\n    // \r\n    StackOverflowCrash = 'stack-overflow',\r\n\r\n    // \r\n    SubtotalAggregation = 'subtotal-aggregation',\r\n\r\n    // \r\n    Subtotals = 'subtotals',\r\n\r\n    // \r\n    SwapFields = 'swap-fields',\r\n\r\n    // \r\n    SwapRowsAndColumns = 'swap-rows-and-columns',\r\n\r\n    // \r\n    TableauException = 'tableau-exception',\r\n\r\n    // \r\n    ToggleDropLines = 'toggle-drop-lines',\r\n\r\n    // \r\n    ToggleFieldBlending = 'toggle-field-blending',\r\n\r\n    // \r\n    ToggleMarkLabels = 'toggle-mark-labels',\r\n\r\n    // \r\n    TogglePageTitle = 'toggle-page-title',\r\n\r\n    // \r\n    ToggleParameterCtrlDisplayFlag = 'toggle-parameter-ctrl-display-flag',\r\n\r\n    // \r\n    ToggleParameterCtrlTitle = 'toggle-parameter-ctrl-title',\r\n\r\n    // \r\n    ToggleQuickFilterTitle = 'toggle-quick-filter-title',\r\n\r\n    // \r\n    ToggleVizNavigationSetting = 'toggle-viz-navigation-setting',\r\n\r\n    // \r\n    Undo = 'undo',\r\n\r\n    // \r\n    UnhideData = 'unhide-data',\r\n\r\n    // \r\n    UnhideLabel = 'unhide-label',\r\n\r\n    // \r\n    UpdateAreaAnnotation = 'update-area-annotation',\r\n\r\n    // \r\n    UpdateCalcScopeIsolation = 'update-scope-isolation-for-calculation',\r\n\r\n    // \r\n    UpdateDataServerConnectionInfo = 'update-data-server-connection-info',\r\n\r\n    // \r\n    UpdatePointAnnotationPullback = 'update-point-annotation-pullback',\r\n\r\n    // \r\n    UpdateTableCalcInfo = 'update-table-calc-infomation',\r\n\r\n    // \r\n    UpgradeExtract = 'upgrade-extract',\r\n\r\n    // \r\n    UseExtract = 'use-extract',\r\n\r\n    // \r\n    ValidateDrillPathName = 'validate-drill-path-name',\r\n\r\n    // \r\n    ValidateFormula = 'validate-formula',\r\n\r\n    // \r\n    ValidateInitialSQL = 'validate-initial-sql',\r\n\r\n    // \r\n    ValidateQueryBanding = 'validate-query-banding',\r\n\r\n    // \r\n    ValidateTypeInPill = 'validate-type-in-pill',\r\n\r\n    // \r\n    ViewParameterCtrls = 'view-param-ctrls',\r\n\r\n    // \r\n    ViewQuickFilters = 'view-quick-filters',\r\n\r\n    // \r\n    GetSchema = 'get-schema',\r\n\r\n    // \r\n    GetSchemaViewerDataSchema = 'get-schema-viewer-data-schema',\r\n\r\n    // \r\n    ConvertToDimension = 'convert-to-dimension',\r\n\r\n    // \r\n    ConvertToMeasure = 'convert-to-measure',\r\n\r\n    // \r\n    ConvertToContinuous = 'convert-to-continuous',\r\n\r\n    // \r\n    ConvertToDiscrete = 'convert-to-discrete',\r\n\r\n    // \r\n    RenameField = 'rename-field',\r\n\r\n    // \r\n    HideField = 'hide-field',\r\n\r\n    // \r\n    UnhideField = 'unhide-field',\r\n\r\n    // \r\n    HideUnusedFields = 'hide-unused-fields',\r\n\r\n    // \r\n    DuplicateFields = 'duplicate-fields',\r\n\r\n    // \r\n    CleanValues = 'clean-values',\r\n\r\n    // \r\n    ParseDate = 'parse-date',\r\n\r\n    // \r\n    MakeDate = 'make-date',\r\n\r\n    // \r\n    SetQualifyNames = 'set-qualify-names',\r\n\r\n    // \r\n    CreateMeasureFromColumn = 'create-measure-from-column',\r\n\r\n    // \r\n    RemoveFromSchemaDrillPath = 'remove-from-schema-drill-path',\r\n\r\n    // \r\n    AddToSchemaDrillPath = 'add-to-schema-drill-path',\r\n\r\n    // \r\n    RemoveSchemaDrillPath = 'remove-schema-drill-path',\r\n\r\n    // \r\n    ShowHiddenFields = 'show-hidden-fields',\r\n\r\n    // \r\n    ShowAliases = 'show-aliases',\r\n\r\n    // \r\n    SetRowDisplayCount = 'set-row-display-count',\r\n\r\n    // \r\n    ShowStructure = 'show-structure',\r\n\r\n    // \r\n    GroupByTable = 'group-by-table',\r\n\r\n    // \r\n    ChangeDataType = 'change-data-type',\r\n\r\n    // \r\n    ChangePivotStrategy = 'change-pivot-strategy',\r\n\r\n    // \r\n    ChangeDisplayAlias = 'change-display-alias',\r\n\r\n    // \r\n    SetIncludeSharedMembers = 'set-include-shared-members',\r\n\r\n    // \r\n    SetUtilityDimension = 'set-utility-dimension',\r\n\r\n    // \r\n    SetDefaultHierarchy = 'set-default-hierarchy',\r\n\r\n    // \r\n    DataSourceSortOrder = 'data-source-sort-order',\r\n\r\n    // \r\n    ClearUtilityDimension = 'clear-utility-dimension',\r\n\r\n    // \r\n    ClearDefaultSort = 'clear-default-sort',\r\n\r\n    // \r\n    SetDefaultAggregation = 'set-default-aggregation',\r\n\r\n    // \r\n    SetDefaultVTAggregation = 'set-default-vtaggregation',\r\n\r\n    // \r\n    ChangeFiscalYear = 'change-fiscal-year',\r\n\r\n    // \r\n    ChangeSemanticRole = 'change-semantic-role',\r\n\r\n    // \r\n    AddToSheet = 'add-to-sheet',\r\n\r\n    // \r\n    DropSchemaSelOnShelf = 'drop-schema-sel-on-shelf',\r\n\r\n    // \r\n    AddToSchemaFieldFolder = 'add-to-schema-field-folder',\r\n\r\n    // \r\n    RemoveFromSchemaFieldFolder = 'remove-from-schema-field-folder',\r\n\r\n    // \r\n    RemoveSchemaFieldFolder = 'remove-schema-field-folder',\r\n\r\n    // \r\n    DefaultTextFormat = 'default-text-format',\r\n\r\n    // \r\n    EditSchemaCaption = 'edit-schema-caption',\r\n\r\n    // \r\n    ResetSchemaCaption = 'reset-schema-caption',\r\n\r\n    // \r\n    CreateOutlierSet = 'create-outlier-set',\r\n}\r\n\r\nexport enum UICommands {\r\n\r\n\r\n    // \r\n    About = 'about',\r\n\r\n    // \r\n    AddDataServerDataSourceUI = 'add-data-server-datasource-ui',\r\n\r\n    // \r\n    SwitchToDocumentAndAddDataServerDataSourceUI = 'switch-to-document-and-add-data-server-ds-ui',\r\n\r\n    // \r\n    AddDrillPathUI = 'add-drillpath-ui',\r\n\r\n    // \r\n    AddFieldFolderUI = 'add-field-folder-ui',\r\n\r\n    // \r\n    AddFileToExtractUI = 'add-file-to-extract-ui',\r\n\r\n    // \r\n    AddDataSourceToExtractUI = 'add-data-source-to-extract-ui',\r\n\r\n    // \r\n    AddQCToSheetUI = 'add-qc-to-sheet-ui',\r\n\r\n    // \r\n    AddReferenceLineUI = 'add-reference-line-ui',\r\n\r\n    // \r\n    AddSchemaFieldFolderUI = 'add-to-schema-field-folder-ui',\r\n\r\n    // \r\n    AddTableauServerDSConnectionUI = 'add-tableau-server-ds-connection-ui',\r\n\r\n    // \r\n    AddToSchemaDrillPathUI = 'add-to-schema-drillpath-ui',\r\n\r\n    // \r\n    AddToSheetUI = 'add-to-sheet-ui',\r\n\r\n    // \r\n    AnnotateUI = 'annotate-ui',\r\n\r\n    // \r\n    AppendDataSourceToRemoteExtractUI = 'append-data-source-to-remote-extract-ui',\r\n\r\n    // \r\n    AttemptConnectDataSourcesOnSheetUI = 'attempt-connect-datasources-on-sheet-ui',\r\n\r\n    // \r\n    AttemptDataSourceConnectionUI = 'attempt-datasource-connect-ui',\r\n\r\n    // \r\n    AutoHideSheet = 'auto-hide-sheet',\r\n\r\n    // \r\n    AutomationClickMRUItem = 'click-mru-item',\r\n\r\n    // \r\n    CalculatedMembersUI = 'calculated-members-ui',\r\n\r\n    // \r\n    ChangeAggregationUI = 'change-aggregation-ui',\r\n\r\n    // \r\n    ChangeDataServerLogonUI = 'change-data-server-logon-ui',\r\n\r\n    // \r\n    ChangeEssbaseAliasFile = 'change-essbase-alias-file',\r\n\r\n    // \r\n    ChangeFieldTypeUI = 'change-field-type-ui',\r\n\r\n    // \r\n    ChangeTabColorSheet = 'change-tab-color-sheet',\r\n\r\n    // \r\n    CheckForProductUpdates = 'check-for-product-updates',\r\n\r\n    // \r\n    ClearDashboardUI = 'clear-dashboard-ui',\r\n\r\n    // \r\n    ClearSheetUI = 'clear-sheet-ui',\r\n\r\n    // \r\n    ClearStoryUI = 'clear-story-ui',\r\n\r\n    // \r\n    ClearVizUI = 'clear-viz-ui',\r\n\r\n    // \r\n    CloseCalculationUI = 'close-calculation-ui',\r\n\r\n    // \r\n    CloseDataSourceUI = 'close-datasource-ui',\r\n\r\n    // \r\n    CloseWorkbook = 'close-workbook',\r\n\r\n    // \r\n    ColorLegendEditUI = 'color-legend-edit-ui',\r\n\r\n    // \r\n    CommitPillEditUI = 'commit-pill-edit-ui',\r\n\r\n    // \r\n    ConnectDataSourceUI = 'connect-datasource-ui',\r\n\r\n    // \r\n    ConnectRepromptUI = 'connect-reprompt-ui',\r\n\r\n    // \r\n    ConnectVariablePromptUI = 'connect-variable-prompt-ui',\r\n\r\n    // \r\n    ConnectVariablePromptMatchingUI = 'connect-variable-prompt-matching-ui',\r\n\r\n    // \r\n    ConnectionAddNewCustomSQLUI = 'connection-add-new-custom-sql-ui',\r\n\r\n    // \r\n    ConnectionAddNewTableUI = 'connection-add-new-table-ui',\r\n\r\n    // \r\n    ConnectionDataGridCopyUI = 'connection-data-grid-copy-ui',\r\n\r\n    // \r\n    ConnectionEditCustomSQLUI = 'connection-custom-sql-ui',\r\n\r\n    // \r\n    ConnectionEditExtractUI = 'connection-extract-ui',\r\n\r\n    // \r\n    ConnectionEditDBVariablesUI = 'connection-edit-db-variables-ui',\r\n\r\n    // \r\n    ConnectionEditConnectionUI = 'connection-edit-connection-ui',\r\n\r\n    // \r\n    ConnectionFinalizeDataSourceUI = 'connection-finalize-datasource-ui',\r\n\r\n    // \r\n    ConnectionFinalizeExtractStatesUI = 'connection-finalize-extract-states-ui',\r\n\r\n    // \r\n    ConnectionGetTypeGroupPresModelUI = 'connection-get-type-group-pres-model-ui',\r\n\r\n    // \r\n    ConnectionGetSavedDataSourcesPresModelUI = 'connection-get-saved-ds-pres-model-ui',\r\n\r\n    // \r\n    ConnectionPartitioningFailureUI = 'connection-partitioning-failure-ui',\r\n\r\n    // \r\n    ConnectionReplaceTableUI = 'connection-replace-table-ui',\r\n\r\n    // \r\n    ConnectionSearchCatalogUI = 'connection-search-catalog-ui',\r\n\r\n    // \r\n    ConnectionSearchCubeUI = 'connection-search-cube-ui',\r\n\r\n    // \r\n    ConnectionSelectCatalogUI = 'connection-select-catalog-ui',\r\n\r\n    // \r\n    ConnectionSelectCubeUI = 'connection-select-cube-ui',\r\n\r\n    // \r\n    ConnectionSelectStandardConnectionUI = 'connection-select-standard-connection-ui',\r\n\r\n    // \r\n    ConnectionSelectStoredProcedureUI = 'connection-select-stored-procedure-ui',\r\n\r\n    // \r\n    ConnectionShowEditTableDialogUI = 'connection-show-edit-table-ui',\r\n\r\n    // \r\n    ConnectionShowPivotDialogUI = 'conneciton-show-pivot-dialog-ui',\r\n\r\n    // \r\n    ConnectionSortCatalogUI = 'connection-sort-catalog-ui',\r\n\r\n    // \r\n    ConnectionSortCubeUI = 'connection-sort-cube-ui',\r\n\r\n    // \r\n    ConnectionValidateCustomSQLUI = 'connection-validate-custom-sql-ui',\r\n\r\n    // \r\n    ConnectToCloudFile = 'connect-to-cloud-file',\r\n\r\n    // \r\n    ConnectToDataServerSourceUI = 'connect-data-server-datasource-ui',\r\n\r\n    // \r\n    ConnectionConvertToSQLUI = 'connection-convert-to-sql-ui',\r\n\r\n    // \r\n    ConnectionRenameConnectionUI = 'connection-rename-connection-ui',\r\n\r\n    // \r\n    ExportUnderlyingDataToCSVUI = 'export-to-csv-with-progress-ui',\r\n\r\n    // \r\n    ConnectODBCUI = 'connect-odbc-ui',\r\n\r\n    // \r\n    CopyCrosstab = 'copy-crosstab',\r\n\r\n    // \r\n    CopyData = 'copy-data',\r\n\r\n    // \r\n    CopyDrillPathFieldsUI = 'copy-drill-path-fields-ui',\r\n\r\n    // \r\n    CopyFieldsDefnUI = 'copy-fields-defn-ui',\r\n\r\n    // \r\n    CopyImage = 'copy-image',\r\n\r\n    // \r\n    CopyImageDashboard = 'copy-image-dashboard',\r\n\r\n    // \r\n    CopyImageWorksheet = 'copy-image-worksheet',\r\n\r\n    // \r\n    CopyImageStory = 'copy-image-story',\r\n\r\n    // \r\n    CopyWorksheetFormatting = 'copy-formatting',\r\n\r\n    // \r\n    CreateCalculatedSetUI = 'create-calculated-set-ui',\r\n\r\n    // \r\n    CreateCalculationUI = 'create-calculation-ui',\r\n\r\n    // \r\n    CreateCombinedFieldUI = 'create-combined-field-ui',\r\n\r\n    // \r\n    CreateConnectionUI = 'create-connection-ui',\r\n\r\n    // \r\n    CreateDateBinUI = 'create-Date-bin-ui',\r\n\r\n    // \r\n    CreateGroupSelectionUI = 'create-group-selection-ui',\r\n\r\n    // \r\n    CreateGroupUI = 'create-group-ui',\r\n\r\n    // \r\n    CreateIdentitySet = 'create-user-filter',\r\n\r\n    // \r\n    CreateLeafConnectionUI = 'create-leaf-connection-ui',\r\n\r\n    // \r\n    CreateNumericBinsUI = 'create-numeric-bins-ui',\r\n\r\n    // \r\n    CreateSetUI = 'create-set-ui',\r\n\r\n    // \r\n    CustomDateAggregationUI = 'custom-date-aggregation-ui',\r\n\r\n    // \r\n    CutDrillPathFieldsUI = 'cut-drill-path-fields-ui',\r\n\r\n    // \r\n    CutFieldsDefnUI = 'cut-fields-defn-ui',\r\n\r\n    // \r\n    DeactivateDashboard = 'deactivate-dashboard',\r\n\r\n    // \r\n    DeleteCookies = 'delete-cookies',\r\n\r\n    // \r\n    DeleteFieldsUI = 'delete-fields-ui',\r\n\r\n    // \r\n    DeleteSheetUI = 'delete-sheet-ui',\r\n\r\n    // \r\n    DescribeAdhocClusterUI = 'describe-adhoc-cluster-ui',\r\n\r\n    // \r\n    DescribeDrillPathUI = 'describe-drillpath-ui',\r\n\r\n    // \r\n    DescribeFieldUI = 'describe-field-ui',\r\n\r\n    // \r\n    DescribeForecastUI = 'describe-forecast-ui',\r\n\r\n    // \r\n    DescribeSchemaDrillPathUI = 'describe-schema-drillpath-ui',\r\n\r\n    // \r\n    DescribeTrendLine = 'describe-trend-line',\r\n\r\n    // \r\n    DescribeTrendModel = 'describe-trend-model',\r\n\r\n    // \r\n    OpenDiscoverPaneLinks = 'open-discover-pane-links',\r\n\r\n    // \r\n    DismissGoToWorksheetTooltipUI = 'dismiss-go-to-worksheet-tooltip-ui',\r\n\r\n    // \r\n    DownloadCopyDataSource = 'download-copy-data-source',\r\n\r\n    // \r\n    DrilldownUI = 'drilldown-ui',\r\n\r\n    // \r\n    DropSchemaSelOnShelfUI = 'drop-schema-sel-on-shelf-ui',\r\n\r\n    // \r\n    DropUI = 'drop-ui',\r\n\r\n    // \r\n    DuplicateDataSourceUI = 'duplicate-datasource-ui',\r\n\r\n    // \r\n    DuplicateSheetAsCrosstab = 'duplicate-sheet-as-crosstab',\r\n\r\n    // \r\n    DuplicateSheetOrCrosstabUI = 'duplicate-sheet-or-crosstab-ui',\r\n\r\n    // \r\n    DuplicateSheetUI = 'duplicate-sheet-ui',\r\n\r\n    // \r\n    EditAliasesUI = 'edit-aliases-ui',\r\n\r\n    // \r\n    EditAnnotation = 'edit-annotation',\r\n\r\n    // \r\n    EditAxisUI = 'edit-axis-ui',\r\n\r\n    // \r\n    EditCalculatedSetUI = 'edit-calculated-set-ui',\r\n\r\n    // \r\n    EditCalculationUI = 'edit-calculation-ui',\r\n\r\n    // \r\n    EditCaptionUI = 'edit-caption',\r\n\r\n    // \r\n    EditCombinedFieldUI = 'edit-combined-field',\r\n\r\n    // \r\n    EditCopyFieldUI = 'edit-copy-field-ui',\r\n\r\n    // \r\n    EditDataSourceUI = 'edit-datasource-ui',\r\n\r\n    // \r\n    EditDataSourceFieldAliases = 'edit-datasource-field-aliases',\r\n\r\n    // \r\n    EditDataSourceFiltersUI = 'edit-datasource-filters-ui',\r\n\r\n    // \r\n    EditDataSourceSitePathsUI = 'edit-datasource-site-paths-ui',\r\n\r\n    // \r\n    EditDateBinUI = 'edit-date-bin-ui',\r\n\r\n    // \r\n    EditDefaultSortUI = 'edit-default-sort-ui',\r\n\r\n    // \r\n    EditDropLinesUI = 'edit-drop-lines-ui',\r\n\r\n    // \r\n    EditDropFieldUI = 'edit-drop-field-ui',\r\n\r\n    // \r\n    EditDataSourceRelationshipsUI = 'edit-datasource-relationships-ui',\r\n\r\n    // \r\n    EditEnumeratedSetUI = 'edit-enumerated-set',\r\n\r\n    // \r\n    EditFilterQuickFilter = 'edit-filter-quick-filter',\r\n\r\n    // \r\n    EditFilterUI = 'edit-filter-ui',\r\n\r\n    // \r\n    EditForecastUI = 'edit-forecast-ui',\r\n\r\n    // \r\n    EditGroupUI = 'edit-group-ui',\r\n\r\n    // \r\n    EditGroupValue = 'edit-group-value',\r\n\r\n    // \r\n    EditGroupValueLabel = 'edit-group-value-label',\r\n\r\n    // \r\n    EditLegendGroupValueUI = 'edit-group-value-legend',\r\n\r\n    // \r\n    EditImageUI = 'edit-image-ui',\r\n\r\n    // \r\n    EditLegendMemberAliasUI = 'edit-legend-member-alias-ui',\r\n\r\n    // \r\n    EditLegendTitleUI = 'edit-legend-title-ui',\r\n\r\n    // \r\n    EditMarkColorUI = 'edit-mark-color-ui',\r\n\r\n    // \r\n    EditMarkShapeUI = 'edit-mark-shape-ui',\r\n\r\n    // \r\n    EditMemberAlias = 'edit-member-alias',\r\n\r\n    // \r\n    EditMemberAliasLabel = 'edit-member-alias-label',\r\n\r\n    // \r\n    EditPageTitleUI = 'edit-page-title-ui',\r\n\r\n    // \r\n    EditParameterCtrlTitle = 'edit-param-control-title',\r\n\r\n    // \r\n    EditPdfPageSelectionUI = 'edit-pdf-page-selection-ui',\r\n\r\n    // \r\n    EditPrimaryAliasesUI = 'edit-primary-aliases-ui',\r\n\r\n    // \r\n    EditReferenceLine = 'edit-reference-line',\r\n\r\n    // \r\n    EditSchemaCalculationUI = 'edit-schema-calculation-ui',\r\n\r\n    // \r\n    EditSchemaCalculationRangeUI = 'edit-schema-calculation-range-ui',\r\n\r\n    // \r\n    EditSchemaCaptionUI = 'edit-schema-caption-ui',\r\n\r\n    // \r\n    EditSchemaFieldAliasUI = 'edit-schema-field-alias-ui',\r\n\r\n    // \r\n    ResetSchemaCaptionUI = 'reset-schema-field-alias-ui',\r\n\r\n    // \r\n    ResetMultipleSchemaCaptionsUI = 'reset-multiple-schema-field-alias-ui',\r\n\r\n    // \r\n    EditSchemaNumericBinsUI = 'edit-schema-numeric-bins-ui',\r\n\r\n    // \r\n    EditSetUI = 'edit-set-ui',\r\n\r\n    // \r\n    EditTitleQuickFilter = 'edit-title-quick-filter',\r\n\r\n    // \r\n    EditTitleUI = 'edit-title',\r\n\r\n    // \r\n    EditTooltipUI = 'edit-tooltip',\r\n\r\n    // \r\n    EditTrendLinesUI = 'edit-trend-lines-ui',\r\n\r\n    // \r\n    EditUserDescriptionUI = 'edit-user-description-ui',\r\n\r\n    // \r\n    EditWMSMapTileServer = 'edit-wms-map-tile-server',\r\n\r\n    // \r\n    EditZoneParam = 'edit-zone-param',\r\n\r\n    // \r\n    EditZoneUrl = 'edit-zone-url',\r\n\r\n    // \r\n    EstablishConnectionUI = 'establish-connection-ui',\r\n\r\n    // \r\n    EstablishTableauServerConnectionUI = 'establish-tableau-server-connection-ui',\r\n\r\n    // \r\n    ExecuteUIAutomationButton = 'execute-ui-button-action',\r\n\r\n    // \r\n    ExecuteUIAutomationComboBox = 'execute-ui-combo-box-action',\r\n\r\n    // \r\n    ExecuteUIAutomationGenericWidget = 'execute-ui-generic-widget-action',\r\n\r\n    // \r\n    ExecuteUIAutomationLabel = 'execute-ui-label-action',\r\n\r\n    // \r\n    ExecuteUIAutomationMenu = 'execute-ui-menu-action',\r\n\r\n    // \r\n    ExecuteUIAutomationItemView = 'execute-ui-item-view-action',\r\n\r\n    // \r\n    ExecuteUIAutomationTextBox = 'execute-ui-text-box-action',\r\n\r\n    // \r\n    ExecuteUIAutomationToggleButton = 'execute-ui-toggle-button-action',\r\n\r\n    // \r\n    ExecuteUIAutomationSlider = 'execute-ui-slider-action',\r\n\r\n    // \r\n    ExecuteUIAutomationWindow = 'execute-ui-window-action',\r\n\r\n    // \r\n    ExecuteUIAutomationWebView = 'execute-ui-web-view-action',\r\n\r\n    // \r\n    ExecuteUIAutomationTab = 'execute-ui-tab-action',\r\n\r\n    // \r\n    ExecuteUIAutomationTextBrowser = 'execute-ui-text-browser-action',\r\n\r\n    // \r\n    ExitApplication = 'exit-application',\r\n\r\n    // \r\n    ExportData = 'export-data',\r\n\r\n    // \r\n    ExportDataSourceUI = 'export-datasource-ui',\r\n\r\n    // \r\n    ExportPackagedWorkbook = 'export-packaged',\r\n\r\n    // \r\n    ExportWorkbookSheetsUI = 'export-workbook-sheets-ui',\r\n\r\n    // \r\n    ExtSvcConfigUI = 'ext-svc-config-ui',\r\n\r\n    // \r\n    ExtractHistory = 'extract-history',\r\n\r\n    // \r\n    ExtractPropertiesUI = 'extract-properties-ui',\r\n\r\n    // \r\n    ExtractUI = 'extract-ui',\r\n\r\n    // \r\n    FilterFieldLabelUI = 'filter-field-label-ui',\r\n\r\n    // \r\n    FormatAnnotation = 'format-annotation',\r\n\r\n    // \r\n    FormatAxisUI = 'format-axis-ui',\r\n\r\n    // \r\n    FormatCaptionTitleUI = 'format-caption-title',\r\n\r\n    // \r\n    FormatField = 'format-pane',\r\n\r\n    // \r\n    FormatFieldLabelUI = 'format-field-label-ui',\r\n\r\n    // \r\n    FormatLabel = 'format-label',\r\n\r\n    // \r\n    FormatLegendsUI = 'format-legends-ui',\r\n\r\n    // \r\n    FormatReferenceLine = 'format-reference-line',\r\n\r\n    // \r\n    FormatUI = 'format-ui',\r\n\r\n    // \r\n    FullScreen = 'fullscreen',\r\n\r\n    // \r\n    GetDashboardSidePaneMode = 'get-dashboard-sidepane-mode',\r\n\r\n    // \r\n    GetDebuggingInfo = 'get-debugging-info',\r\n\r\n    // \r\n    GetIconPathForEncodingType = 'get-icon-path-for-encoding-type',\r\n\r\n    // \r\n    GetIconPathForPrimitiveType = 'get-icon-path-for-primitive-type',\r\n\r\n    // \r\n    GetTableOptionsPresModel = 'get-table-options-pres-model',\r\n\r\n    // \r\n    GetWindowNameUI = 'get-window-name',\r\n\r\n    // \r\n    GetWorksheetSidePaneMode = 'get-worksheet-sidepane-mode',\r\n\r\n    // \r\n    GetHiddenSheets = 'get-hidden-sheets',\r\n\r\n    // \r\n    GetOpenPaneMRUs = 'get-open-pane-mrus',\r\n\r\n    // \r\n    GetOpenPaneSampleWorkbooks = 'get-open-pane-sample-workbooks',\r\n\r\n    // \r\n    GetRetargetDataSourcePresModelUI = 'get-retarget-datasource-pres-model-ui',\r\n\r\n    // \r\n    GetSchemaViewerPresModel = 'get-schema-viewer-pres-model',\r\n\r\n    // \r\n    GetSelectedSheets = 'get-selected-sheets',\r\n\r\n    // \r\n    GetSheetSorterThumbnail = 'get-sheet-sorter-thumbnail',\r\n\r\n    // \r\n    GetSheetTabUIThumbnail = 'get-sheet-tab-ui-thumbnail',\r\n\r\n    // \r\n    GetSheetTabUIText = 'get-sheet-tab-ui-text',\r\n\r\n    // \r\n    GetVisibleTreeItems = 'get-visible-tree-items',\r\n\r\n    // \r\n    GotoSheetRange = 'goto',\r\n\r\n    // \r\n    GotoURL = 'goto-url',\r\n\r\n    // \r\n    HideCaptionUI = 'hide-caption',\r\n\r\n    // \r\n    HideFilmstripUI = 'hide-filmstrip-ui',\r\n\r\n    // \r\n    HideTitleUI = 'hide-title',\r\n\r\n    // \r\n    HideZoneUI = 'hide-zone-ui',\r\n\r\n    // \r\n    HideAllSheetsUI = 'hide-all-sheets-ui',\r\n\r\n    // \r\n    UnhideAllSheetsUI = 'unhide-all-sheets-ui',\r\n\r\n    // \r\n    ImportLocalDataUI = 'import-local-data-ui',\r\n\r\n    // \r\n    ImportMapSource = 'import-map-source',\r\n\r\n    // \r\n    ImportMapSourceUI = 'import-map-source-ui',\r\n\r\n    // \r\n    ImportWorkbookUI = 'import-workbook-ui',\r\n\r\n    // \r\n    LoadDefaultFormattingUI = 'load-formatting-ui',\r\n\r\n    // \r\n    LocateFieldUI = 'locate-field-ui',\r\n\r\n    // \r\n    LogMemoryUsage = 'log-memory-usage',\r\n\r\n    // \r\n    ManageLicensing = 'manage-licensing',\r\n\r\n    // \r\n    ManageMapbox = 'manage-mapbox',\r\n\r\n    // \r\n    ManagePublicWorkbooks = 'manage-public',\r\n\r\n    // \r\n    ManageMapServices = 'manage-map-services',\r\n\r\n    // \r\n    MapLayersUI = 'map-layers-ui',\r\n\r\n    // \r\n    ManageWMS = 'manage-wms',\r\n\r\n    // \r\n    UpgradeDataSourcesUI = 'upgrade-datasources-ui',\r\n\r\n    // \r\n    UpgradeDataSourceUI = 'upgrade-datasource-ui',\r\n\r\n    // \r\n    MoveRepository = 'move-repository',\r\n\r\n    // \r\n    NewSchemaDrillPathUI = 'new-schema-drill-path-ui',\r\n\r\n    // \r\n    NewUIDashboard = 'new-dashboard-ui',\r\n\r\n    // \r\n    NewUIWorksheet = 'new-worksheet-ui',\r\n\r\n    // \r\n    NewUIStoryboard = 'new-storyboard-ui',\r\n\r\n    // \r\n    NewWorkbook = 'new-workbook',\r\n\r\n    // \r\n    NextSheet = 'next-sheet',\r\n\r\n    // \r\n    NonRangedEditReferenceLine = 'non-ranged-edit-reference-line',\r\n\r\n    // \r\n    OpenBookmark = 'open-bookmark',\r\n\r\n    // \r\n    OpenFromWorkgroup = 'open-workbook-from-workgroup',\r\n\r\n    // \r\n    OpenMapSource = 'open-map-source',\r\n\r\n    // \r\n    OpenMapSourceUI = 'open-map-source-ui',\r\n\r\n    // \r\n    OpenSampleWorkbook = 'open-sample-workbook',\r\n\r\n    // \r\n    OpenWorkbook = 'open-workbook',\r\n\r\n    // \r\n    OpenRecentWorkbook = 'open-recent-workbook',\r\n\r\n    // \r\n    OpenOtherFiles = 'open-other-files',\r\n\r\n    // \r\n    OptimizeExtractUI = 'optimize-extract-ui',\r\n\r\n    // \r\n    PageSetup = 'page-setup',\r\n\r\n    // \r\n    Paste = 'paste',\r\n\r\n    // \r\n    PasteFieldsDefnUI = 'paste-fields-defn-ui',\r\n\r\n    // \r\n    PasteWorksheetFormatting = 'paste-formatting',\r\n\r\n    // \r\n    PDFExport = 'export-pdf',\r\n\r\n    // \r\n    PerspectivesUI = 'perspectives-ui',\r\n\r\n    // \r\n    PresentationMode = 'presentation-mode',\r\n\r\n    // \r\n    Print = 'print',\r\n\r\n    // \r\n    PromptScript = 'prompt-command',\r\n\r\n    // \r\n    PropertiesDataSourceUI = 'properties-datasource-ui',\r\n\r\n    // \r\n    PublishDatasourceToWorkgroup = 'publish-datasource-to-workgroup',\r\n\r\n    // \r\n    PublishDatasourceToWorkgroupFromData = 'publish-datasource-to-workgroup-from-data',\r\n\r\n    // \r\n    PublishDatasourceToWorkgroupRange = 'publish-datasource-to-workgroup-range',\r\n\r\n    // \r\n    PublishWorkbookToWorkgroup = 'publish-workbook-to-workgroup',\r\n\r\n    // \r\n    PublishDatasourceToWorkgroupFromWorkbookData = 'publish-datasource-to-workgroup-from-workbook-data',\r\n\r\n    // \r\n    PromptForDataSourceFileUI = 'prompt-for-datasource-file-ui',\r\n\r\n    // \r\n    PromptUnknownWDCUrlUI = 'prompt-unknown-wdc-url-ui',\r\n\r\n    // \r\n    QueryDataSourceUI = 'query-datasource-ui',\r\n\r\n    // \r\n    QuickFilterFieldLabelUI = 'quick-filter-field-label-ui',\r\n\r\n    // \r\n    QuickTableCalcUI = 'quick-table-calc-ui',\r\n\r\n    // \r\n    ReconnectMapSourceUI = 'reconnect-map-source-ui',\r\n\r\n    // \r\n    RecordPerformance = 'record-perf',\r\n\r\n    // \r\n    RefreshAllExtractsUI = 'refresh-all-extracts-ui',\r\n\r\n    // \r\n    RefreshAllThumbnailsUI = 'refresh-all-thumbnails',\r\n\r\n    // \r\n    RefreshAutoExtractUI = 'refresh-auto-extract-ui',\r\n\r\n    // \r\n    RefreshDataSourceUI = 'refresh-datasource-ui',\r\n\r\n    // \r\n    RefreshExtractUI = 'refresh-extract-ui',\r\n\r\n    // \r\n    RefreshFromSourceUI = 'refresh-from-source-ui',\r\n\r\n    // \r\n    RefreshLocalDataUI = 'refresh-local-data-ui',\r\n\r\n    // \r\n    RefreshThumbnailUI = 'refresh-thumbnail',\r\n\r\n    // \r\n    ReleaseMemory = 'release-memory',\r\n\r\n    // \r\n    RemoveAnnotation = 'remove-annotation',\r\n\r\n    // \r\n    RemoveExtractUI = 'remove-extract-ui',\r\n\r\n    // \r\n    RemoveMRUItem = 'remove-mru',\r\n\r\n    // \r\n    RemoveSavedDataSourceUI = 'remove-saved-datasource',\r\n\r\n    // \r\n    RemoveSheetFromDashboardUI = 'remove-sheet-from-dashboard-ui',\r\n\r\n    // \r\n    RemoveTableUI = 'remove-table-ui',\r\n\r\n    // \r\n    RenameDataSourceUI = 'rename-datasource-ui',\r\n\r\n    // \r\n    RenameSchemaFieldFolderUI = 'rename-field-folder-ui',\r\n\r\n    // \r\n    RenameSchemaDrillPathUI = 'rename-schema-drillpath-ui',\r\n\r\n    // \r\n    RenameSheetUI = 'rename-sheet-ui',\r\n\r\n    // \r\n    ReorderSheetsUI = 'reorder-sheets-ui',\r\n\r\n    // \r\n    ReplaceDataSourceWithDataServerDataSourceUI = 'replace-datasource-with-data-server-datasource-ui',\r\n\r\n    // \r\n    ReplaceFieldUI = 'replace-field-ui',\r\n\r\n    // \r\n    ResetCaptionUI = 'reset-caption-ui',\r\n\r\n    // \r\n    ResetCards = 'reset-cards',\r\n\r\n    // \r\n    ResetLocalDataUI = 'remove-local-data-ui',\r\n\r\n    // \r\n    ResetMessages = 'reset-messages',\r\n\r\n    // \r\n    StartOnlineSyncClient = 'start-online-sync-client',\r\n\r\n    // \r\n    ResetTitleUI = 'reset-title-ui',\r\n\r\n    // \r\n    ResetToDefaultsMapCard = 'reset-map-to-defaults',\r\n\r\n    // \r\n    ResetWorkbook = 'revert-workbook-ui',\r\n\r\n    // \r\n    RetargetDataSource = 'retarget-datasource',\r\n\r\n    // \r\n    RetargetDataSourceUI = 'retarget-datasource-ui',\r\n\r\n    // \r\n    SaveAsWorkbook = 'save-as-workbook',\r\n\r\n    // \r\n    SaveBookmark = 'save-bookmark',\r\n\r\n    // \r\n    SaveDebuggingWorkbook = 'save-debugging-workbook',\r\n\r\n    // \r\n    SaveDefaultFormattingUI = 'save-formatting-ui',\r\n\r\n    // \r\n    SaveWorkbook = 'save-workbook',\r\n\r\n    // \r\n    SchemaDefaultMemberUI = 'schema-default-member-ui',\r\n\r\n    // \r\n    ScrollSheet = 'scroll-sheet',\r\n\r\n    // \r\n    SetAccountsDimension = 'set-accounts-dimension',\r\n\r\n    // \r\n    SetActiveConnectionUI = 'set-active-connection-ui',\r\n\r\n    // \r\n    SetAnalyticsDropTargetVisibility = 'set-analytics-drop-target-visibility',\r\n\r\n    // \r\n    SetDashboardSidePaneMode = 'set-dashboard-sidepane-mode',\r\n\r\n    // \r\n    SetDefaultDateFormatUI = 'set-default-date-format-ui',\r\n\r\n    // \r\n    SetDefaultLocationUI = 'set-default-location-ui',\r\n\r\n    // \r\n    SetDefaultMapSourceUI = 'set-default-mapsource-ui',\r\n\r\n    // \r\n    SetDefaultTextFormatUI = 'set-default-text-format-ui',\r\n\r\n    // \r\n    SetDefaultUtilityMember = 'set-default-utility-member',\r\n\r\n    // \r\n    SetFreeFormDashboardUI = 'set-free-form-dashboard-ui',\r\n\r\n    // \r\n    SetFilterSharedUI = 'set-filter-shared-ui',\r\n\r\n    // \r\n    SetKey = 'set-key',\r\n\r\n    // \r\n    SetProductAutoUpdate = 'set-auto-update',\r\n\r\n    // \r\n    SetQueryFailure = 'set-query-failure',\r\n\r\n    // \r\n    SetRendering = 'set-rendering',\r\n\r\n    // \r\n    SetRuntimeImmediateMode = 'set-runtime-immediate-mode',\r\n\r\n    // \r\n    SetUILanguage = 'set-ui-language',\r\n\r\n    // \r\n    SetWorkbookLocaleUI = 'set-workbook-locale-ui',\r\n\r\n    // \r\n    SetWorksheetSidePaneMode = 'set-worksheet-sidepane-mode',\r\n\r\n    // \r\n    SetZoneFixedSizeUI = 'set-zone-fixed-size-ui',\r\n\r\n    // \r\n    SetsInOutUI = 'show-in-out-sets',\r\n\r\n    // \r\n    ShapeLegendEditUI = 'shape-legend-edit-ui',\r\n\r\n    // \r\n    ShowCloudFileOAuthPromptAndSelectionUI = 'show-cloudfile-oauth-prompt-and-selection-ui',\r\n\r\n    // \r\n    ShowConnectionAuthUI = 'show-connection-auth-ui',\r\n\r\n    // \r\n    ShowConnectionAuthAndEstablishConnectionUI = 'show-connection-auth-and-establish-connection-ui',\r\n\r\n    // \r\n    ShowConnectTab = 'show-connect-tab',\r\n\r\n    // \r\n    ShowCustomSplitDialogUI = 'show-custom-split-dialog-ui',\r\n\r\n    // \r\n    ShowDocument = 'document',\r\n\r\n    // \r\n    ShowFeatureFlagDialog = 'show-feature-flag-dialog',\r\n\r\n    // \r\n    ShowFieldFormatUI = 'show-field-format-ui',\r\n\r\n    // \r\n    ShowFieldInSchemaUI = 'show-field-in-schema',\r\n\r\n    // \r\n    ShowFilmstripUI = 'show-filmstrip-ui',\r\n\r\n    // \r\n    ShowGoogleSheetsSelectionUI = 'show-google-sheets-selection-ui',\r\n\r\n    // \r\n    ShowHelp = 'show-help',\r\n\r\n    // \r\n    ShowHideDashboardSheetUI = 'show-hide-dashboard-sheet-ui',\r\n\r\n    // \r\n    ShowHideStoryboardSheetUI = 'show-hide-storyboard-sheet-ui',\r\n\r\n    // \r\n    ShowGraphicsAPI = 'show-graphics-api-command',\r\n\r\n    // \r\n    ShowMapOptionsDialog = 'show-map-options-dialog',\r\n\r\n    // \r\n    ShowMeasuresUI = 'show-measures-ui',\r\n\r\n    // \r\n    ShowMeCycleUI = 'show-me-cycle-ui',\r\n\r\n    // \r\n    ShowMeHideUI = 'show-me-hide-ui',\r\n\r\n    // \r\n    ShowMembersUI = 'show-members-ui',\r\n\r\n    // \r\n    ShowMeToggleUI = 'show-me-toggle-ui',\r\n\r\n    // \r\n    ShowOAuthPromptUI = 'show-oauth-prompt-ui',\r\n\r\n    // \r\n    ShowParameterControl = 'show-parameter-control',\r\n\r\n    // \r\n    ShowPublicStatusDialog = 'show-public-status-dialog',\r\n\r\n    // \r\n    ShowPublicQuotaExceededDialog = 'show-public-quota-exceeded-dialog',\r\n\r\n    // \r\n    ShowPublishDatasourceToWorkgroupDialog = 'show-publish-datasource-to-workgroup-dialog',\r\n\r\n    // \r\n    ShowQueryBandingAndInitialSQLDialogUI = 'show-query-banding-and-initial-sql-dialog-ui',\r\n\r\n    // \r\n    ShowQuickFilter = 'show-quickfilter',\r\n\r\n    // \r\n    ShowQuickFilterUI = 'show-quickfilter-ui',\r\n\r\n    // \r\n    ShowRuntimeIndicator = 'show-runtime-indicator',\r\n\r\n    // \r\n    ShowSheetSorter = 'sheet-sorter',\r\n\r\n    // \r\n    ShowTableOptionsDialog = 'show-table-options-dialog',\r\n\r\n    // \r\n    ShowWebDataConnectorUI = 'show-web-data-connector-ui',\r\n\r\n    // \r\n    ShowWidgetSandboxUI = 'show-widget-sandbox-ui',\r\n\r\n    // \r\n    SizeLegendEditUI = 'size-legend-edit-ui',\r\n\r\n    // \r\n    SleepUI = 'sleep-ui',\r\n\r\n    // \r\n    SortAscendingFieldLabelUI = 'sort-ascending-field-label-ui',\r\n\r\n    // \r\n    SortDescendingFieldLabelUI = 'sort-descending-field-label-ui',\r\n\r\n    // \r\n    SortFieldLabelUI = 'sort-field-label-ui',\r\n\r\n    // \r\n    SortUI = 'sort-ui',\r\n\r\n    // \r\n    SplitFieldUI = 'split-field-ui',\r\n\r\n    // \r\n    StackMarksUI = 'stack-marks-ui',\r\n\r\n    // \r\n    StartFileConnectionUI = 'start-file-connection-ui',\r\n\r\n    // \r\n    StartPillEditUI = 'start-pill-edit-ui',\r\n\r\n    // \r\n    SwitchToConnectTab = 'switch-to-connect-tab',\r\n\r\n    // \r\n    SwitchToDocument = 'switch-to-document',\r\n\r\n    // \r\n    SwitchToSheetSorter = 'switch-to-sheet-sorter',\r\n\r\n    // \r\n    TableCalcAddressUI = 'table-calc-address-ui',\r\n\r\n    // \r\n    TableCalcIgnoreUI = 'table-calc-ignore-ui',\r\n\r\n    // \r\n    TableCalcOrderingUI = 'table-calc-ordering-ui',\r\n\r\n    // \r\n    TableCalcUI = 'table-calc-ui',\r\n\r\n    // \r\n    ToggleConnectPaneUI = 'toggle-connect-pane',\r\n\r\n    // \r\n    ToggleFilmstripUI = 'toggle-filmstrip-ui',\r\n\r\n    // \r\n    ToggleINDJoinSemanticsUI = 'toggle-ind-join-semantics-ui',\r\n\r\n    // \r\n    TogglePinMRUItem = 'toggle-pin-mru',\r\n\r\n    // \r\n    ToggleReferentialIntegrityUI = 'toggle-referential-integrity-ui',\r\n\r\n    // \r\n    ToggleStartPageUI = 'toggle-start-page',\r\n\r\n    // \r\n    TrackMemory = 'track-memory',\r\n\r\n    // \r\n    TrendLinesFlagUI = 'trend-lines-ui',\r\n\r\n    // \r\n    UpdateDefaultsMapCard = 'update-map-defaults',\r\n\r\n    // \r\n    UpgradeExtractsUI = 'upgrade-extracts-ui',\r\n\r\n    // \r\n    UpgradeExtractUI = 'upgrade-extract-ui',\r\n\r\n    // \r\n    UseExtractUI = 'use-extract-ui',\r\n\r\n    // \r\n    UseMemory = 'use-memory',\r\n\r\n    // \r\n    UtilityDimensionUI = 'utility-dimension-ui',\r\n\r\n    // \r\n    ValidateExtractCredentialsUI = 'validate-extract-credentials-ui',\r\n\r\n    // \r\n    ViewCard = 'view-card',\r\n\r\n    // \r\n    ViewTitleCard = 'view-title-card',\r\n\r\n    // \r\n    ViewSummaryCard = 'view-summary-card',\r\n\r\n    // \r\n    ViewCaptionCard = 'view-caption-card',\r\n\r\n    // \r\n    ViewColumnsShelf = 'view-columns-shelf',\r\n\r\n    // \r\n    ViewRowsShelf = 'view-rows-shelf',\r\n\r\n    // \r\n    ViewPagesShelf = 'view-pages-shelf',\r\n\r\n    // \r\n    ViewFiltersShelf = 'view-filters-shelf',\r\n\r\n    // \r\n    ViewMeasuresShelf = 'view-measures-shelf',\r\n\r\n    // \r\n    ViewMarksShelf = 'view-marks-shelf',\r\n\r\n    // \r\n    ViewCurrentPageCard = 'view-current-page-card',\r\n\r\n    // \r\n    ViewData = 'view-data',\r\n\r\n    // \r\n    ViewSQLDataUI = 'view-sql-data-ui',\r\n\r\n    // \r\n    ViewDataSourceData = 'view-datasource-data',\r\n\r\n    // \r\n    ViewLegend = 'view-legend',\r\n\r\n    // \r\n    ViewSidePane = 'view-side-pane',\r\n\r\n    // \r\n    ViewStatusBar = 'view-statusbar',\r\n\r\n    // \r\n    ViewSummaryDetail = 'view-summary-detail',\r\n\r\n    // \r\n    ViewTableData = 'view-table-data',\r\n\r\n    // \r\n    ViewToolBar = 'view-toolbar',\r\n\r\n    // \r\n    WebViewEnableJavascript = 'webview-enable-javascript',\r\n\r\n    // \r\n    WebViewEnablePlugins = 'webview-enable-plugins',\r\n\r\n    // \r\n    WebViewBlockPopups = 'webview-block-popups',\r\n\r\n    // \r\n    WebViewEnableURLHoverActions = 'webview-enable-url-hover-actions',\r\n\r\n    // \r\n    WorkgroupChangeDataserver = 'workgroup-change-dataserver',\r\n\r\n    // \r\n    WorkgroupChangeServer = 'workgroup-change-server',\r\n\r\n    // \r\n    WorkgroupChangeUser = 'workgroup-change-user',\r\n\r\n    // \r\n    WorkgroupRemoveLastServer = 'workgroup-remove-last-server',\r\n}\r\n\r\nexport enum SrvCommands {\r\n\r\n    // pings the server to test if the session is expired\r\n    PingSession = 'ping-session',\r\n\r\n    // Applies snapshot from comments to the viz.\r\n    ApplyCustomizedView = 'apply-customized-view',\r\n\r\n    // Refreshes VQLSession Data\r\n    RefreshData = 'refresh-data',\r\n\r\n}\r\n\r\nexport enum DocCommands {\r\n\r\n    // Returns whether date properties should be enabled\r\n    GetDataSourceDatePropertiesAreEnabled = 'get-datasource-date-properties-are-enabled',\r\n\r\n    // Get presmodel to populate date properties dialog\r\n    GetDataSourceDateProperties = 'get-datasource-date-properties',\r\n\r\n    // Apply new settings for date properties\r\n    EditDataSourceDateProperties = 'edit-datasource-date-properties',\r\n\r\n    // Apply data source delta to data source\r\n    ApplyDataSourceDelta = 'apply-datasource-delta',\r\n\r\n    // Generate data source delta from local data source\r\n    GetDataSourceDelta = 'get-datasource-delta',\r\n\r\n    // Gets the pres model for the Save Datasource dialog\r\n    GetWebSaveDatasourceDialog = 'get-web-save-datasource-dialog',\r\n\r\n    // Creates a dialog in the browser to rename the datasource\r\n    WebRenameDatasourceDialog = 'web-rename-datasource-dialog',\r\n\r\n    // Switches the view to the data tab for editing\r\n    WebEditDataSource = 'web-edit-data-source',\r\n\r\n    // Toggles joining on null values\r\n    ToggleINDJoinSemantics = 'toggle-ind-join-semantics',\r\n\r\n    // Join Null Values to Null Values\r\n    ToggleINDJoinSemanticsWrapper = 'toggle-indjoin-semantics-wrapper',\r\n\r\n    // Toggles referential integrity\r\n    ToggleReferentialIntegrity = 'toggle-referential-integrity',\r\n\r\n    // Retrieves list of summary objects, one for each connection in a datasource.\r\n    GetConnectionDescriptionSummaryPresModels = 'get-connection-description-summary-pres-models',\r\n\r\n    // Gets the axis options .\r\n    GetAxisOptions = 'get-axis-options',\r\n\r\n    // Reset the axis options .\r\n    ResetAxisOptions = 'reset-axis-options',\r\n\r\n    // Show axis edit dialog\r\n    ShowEditAxisDialog = 'show-edit-axis-dialog',\r\n\r\n    // Sets the axis direction\r\n    SetAxisReversed = 'set-axis-reversed',\r\n\r\n    // Sets the axis scale type\r\n    SetAxisScaleType = 'set-axis-scale-type',\r\n\r\n    // Sets the main title of a quantitative axis\r\n    SetAxisTitle = 'set-axis-title',\r\n\r\n    // Sets the subtitle of a quantitative axis\r\n    SetAxisSubtitle = 'set-axis-subtitle',\r\n\r\n    // Sets whether we should use the automatic subtitle for a quantitative axis\r\n    SetAxisUseAutomaticSubtitle = 'set-axis-use-automatic-subtitle',\r\n\r\n    // Sets the axis range type of a quantitative axis\r\n    SetAxisExtentStartType = 'set-axis-extent-start-type',\r\n\r\n    // Sets the axis range type of a quantitative axis\r\n    SetAxisExtentEndType = 'set-axis-extent-end-type',\r\n\r\n    // Sets the axis range type of a quantitative axis\r\n    SetBothAxisExtentsType = 'set-both-axis-extents-type',\r\n\r\n    // Sets whether or not to force-include zero on a quantitative axis\r\n    SetAxisIncludeZero = 'set-axis-include-zero',\r\n\r\n    // Sets new min/max range endings for axis\r\n    SetAxisRangeEnd = 'set-axis-range-end',\r\n\r\n    // Sets new min/max range endings for axis\r\n    SetAxisRangeStart = 'set-axis-range-start',\r\n\r\n    // Synchronize dual axes on a folded quantitative axis\r\n    SetAxisFoldState = 'set-axis-fold-state',\r\n\r\n    // Set the major tick mark state\r\n    SetMajorTickMarkState = 'set-major-tick-mark-state',\r\n\r\n    // Set the minor tick mark state\r\n    SetMinorTickMarkState = 'set-minor-tick-mark-state',\r\n\r\n    // Set the major tick mark origin\r\n    SetMajorTickMarkOrigin = 'set-major-tick-mark-origin',\r\n\r\n    // Set the minor tick mark origin\r\n    SetMinorTickMarkOrigin = 'set-minor-tick-mark-origin',\r\n\r\n    // Set the major tick mark spacing\r\n    SetMajorTickMarkSpacing = 'set-major-tick-mark-spacing',\r\n\r\n    // Set the minor tick mark spacing\r\n    SetMinorTickMarkSpacing = 'set-minor-tick-mark-spacing',\r\n\r\n    // Set the major tick mark units\r\n    SetMajorTickMarkUnits = 'set-major-tick-mark-units',\r\n\r\n    // Set the minor tick mark units\r\n    SetMinorTickMarkUnits = 'set-minor-tick-mark-units',\r\n\r\n\r\n    // \r\n    BoundingBoxPan = 'bounding-box-pan',\r\n\r\n    // \r\n    OnToggleAxisRanges = 'on-toggle-axis-ranges',\r\n\r\n    // \r\n    PanePan = 'pane-pan',\r\n\r\n    // \r\n    PaneZoom = 'pane-zoom',\r\n\r\n    // \r\n    PaneZoomFactor = 'pane-zoom-factor',\r\n\r\n    // \r\n    PaneZoomPan = 'pane-zoom-pan',\r\n\r\n    // \r\n    ReorderFoldedAxes = 'reorder-folded-axes',\r\n\r\n    // \r\n    ResetAxisRange = 'reset-axis-range',\r\n\r\n    // \r\n    SelectAxisTuples = 'select-axis-tuples',\r\n\r\n    // \r\n    SwapReferenceLineFields = 'swap-reference-line-fields',\r\n\r\n    // \r\n    SynchronizeAxis = 'synchronize-axis',\r\n\r\n    // \r\n    ToggleDualAxis = 'toggle-dual-axis',\r\n\r\n    // \r\n    ZoomLevel = 'zoom-level',\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/gen-src/preslayer/CommandIds.ts\n **/","import { VerbId as ApiVerbId } from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { CommandRegistration } from './CommandRegistration';\r\n\r\n/**\r\n * Registry which contains mappings from an Api VerbId to a pres-layer command.\r\n * This includes the parameters and return values of the command as well\r\n *\r\n * @export\r\n * @class CommandMappingRegistry\r\n */\r\nexport class CommandMappingRegistry {\r\n  private static UNKNOWN_APIVERB: string = 'Unknown ApiVerb: %1';\r\n  private _commands: { [apiVerb: string]: CommandRegistration };\r\n\r\n  /**\r\n   * Creates an instance of CommandMappingRegistry.\r\n   * @memberof CommandMappingRegistry\r\n   */\r\n  public constructor() {\r\n    this._commands = {};\r\n  }\r\n\r\n  /**\r\n   * Adds a new command to the registry\r\n   *\r\n   * @param {CommandRegistration} command\r\n   * @memberof CommandMappingRegistry\r\n   */\r\n  public addCommand(command: CommandRegistration): void {\r\n    this._commands[command.apiVerbId] = command;\r\n  }\r\n\r\n  /**\r\n   * Whether or not this registry contains a definition for this ApiVerbId\r\n   *\r\n   * @param {ApiVerbId} apiVerbId\r\n   * @returns {boolean}\r\n   * @memberof CommandMappingRegistry\r\n   */\r\n  public hasCommand(apiVerbId: ApiVerbId): boolean {\r\n    if (!this._commands.hasOwnProperty(apiVerbId)) {\r\n      return false;\r\n    }\r\n\r\n    if (!this._commands[apiVerbId]) {\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Gets the command registration for this command id or throws if it doesn't exist\r\n   *\r\n   * @param {ApiVerbId} apiVerbId\r\n   * @returns {CommandRegistration}\r\n   * @memberof CommandMappingRegistry\r\n   */\r\n  public getCommand(apiVerbId: ApiVerbId): CommandRegistration {\r\n    if (!this.hasCommand(apiVerbId)) {\r\n      throw TableauException.error(CommandMappingRegistry.UNKNOWN_APIVERB, [apiVerbId]);\r\n    }\r\n\r\n    return this._commands[apiVerbId];\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/CommandMappingRegistry.ts\n **/","import {\r\n  ExecuteParameters,\r\n  Model,\r\n  ParameterId as ApiParameterId,\r\n  VerbId as ApiVerbId,\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport {\r\n  DocCommands as PresLayerDocCommandId,\r\n  SrvCommands as PresLayerSrvCommandId,\r\n  UICommands as PresLayerUICommandId\r\n} from '../../gen-src/preslayer/CommandIds';\r\n\r\nimport { ParameterId as PresLayerParameterId } from '../../gen-src/preslayer/Params';\r\nimport { ApiToPresLayerMappingRegistry, PresLayerToApiMappingRegistry } from './ParameterMappingRegistryFactory';\r\n\r\n/**\r\n * This is an enum used only internally by the api-core project.\r\n * This enum represents the difference namespaces available for commands.\r\n */\r\nexport enum CommandNamespace {\r\n  TabDoc = 'tabdoc',\r\n  TabSrv = 'tabsrv',\r\n  TabUI = 'tabui'\r\n}\r\n\r\n/**\r\n * Represents an input or output paramter for a command.\r\n *\r\n * @export\r\n * @class CommandParameter\r\n */\r\nexport class CommandParameter {\r\n  /**\r\n   * Creates an instance of CommandParameter.\r\n   * @param {ApiParameterId} apiId\r\n   * @param {PresLayerParameterId} presLayerId\r\n   * @param {boolean} [isOptional]\r\n   * @memberof CommandParameter\r\n   */\r\n  public constructor(\r\n    private _apiId: ApiParameterId,\r\n    private _presLayerId: PresLayerParameterId,\r\n    private _isOptional?: boolean) { }\r\n\r\n  /**\r\n   * The Id of the Api Parameter\r\n   *\r\n   * @readonly\r\n   * @type {ApiParameterId}\r\n   * @memberof CommandParameter\r\n   */\r\n  public get apiId(): ApiParameterId {\r\n    return this._apiId;\r\n  }\r\n\r\n  /**\r\n   * The Id of the Pres Layer Parameter\r\n   *\r\n   * @readonly\r\n   * @type {PresLayerParameterId}\r\n   * @memberof CommandParameter\r\n   */\r\n  public get presLayerId(): PresLayerParameterId {\r\n    return this._presLayerId;\r\n  }\r\n\r\n  /**\r\n   * Whether or not this is an optional parameter\r\n   *\r\n   * @readonly\r\n   * @type {boolean}\r\n   * @memberof CommandParameter\r\n   */\r\n  public get isOptional(): boolean {\r\n    return !!this._isOptional;\r\n  }\r\n}\r\n\r\n/**\r\n * Represents a the complete mapping of an ApiCommand to its corresponding pres-layer command\r\n * and the conversion of the output value as well\r\n *\r\n * @export\r\n * @class CommandRegistration\r\n *\r\n * @param {ApiVerbId} _apiVerbId the internal api verb ID of this command.\r\n * @param {PresLayerDocCommandId | PresLayerSrvCommandId | PresLayerUICommandId} _commandId\r\n *   the pres layer command to execute\r\n * @param {CommandParameter[]} _inputParameters list of parameters to send with this command to the platform.\r\n * @param {CommandParameter} [isOptional] expected return paramters from the platform.\r\n * @param {CommandNamespace} [isOptional] namespace of the command (defaults to TabDoc if not provided).\r\n */\r\nexport class CommandRegistration {\r\n  public constructor(\r\n    private _apiVerbId: ApiVerbId,\r\n    private _commandId: PresLayerDocCommandId | PresLayerSrvCommandId | PresLayerUICommandId,\r\n    private _inputParameters: CommandParameter[],\r\n    private _outputParameter?: CommandParameter,\r\n    private _namespace?: CommandNamespace,\r\n  ) { }\r\n\r\n  public get apiVerbId(): ApiVerbId {\r\n    return this._apiVerbId;\r\n  }\r\n\r\n  public get commandId(): PresLayerDocCommandId | PresLayerSrvCommandId | PresLayerUICommandId {\r\n    return this._commandId;\r\n  }\r\n\r\n  public get namespace(): CommandNamespace {\r\n    return this._namespace || CommandNamespace.TabDoc;\r\n  }\r\n\r\n  public get inputs(): CommandParameter[] {\r\n    return this._inputParameters || new Array<CommandParameter>();\r\n  }\r\n\r\n  public get output(): CommandParameter | undefined {\r\n    return this._outputParameter;\r\n  }\r\n\r\n  /**\r\n   * Whether or not this command requires an add-in locator to be injected into it\r\n   *\r\n   * @readonly\r\n   * @type {boolean}\r\n   * @memberof CommandRegistration\r\n   */\r\n  public get needsAddInLocator(): boolean {\r\n    for (const input of this.inputs) {\r\n      if (input.apiId === ApiParameterId.ExtensionLocator) {\r\n        return true;\r\n      }\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Creates a dictionary of pres-layer parameters from the input dictionary\r\n   * of api parameters.\r\n   *\r\n   * @param {ExecuteParameters} parameters - The parameters to convert\r\n   * @param {ApiToPresLayerMappingRegistry} apiToPresLayer - mapping to determine the conversion\r\n   * @returns {{ [paramId: string]: object; }} - parameters to send to the pres-layer\r\n   * @memberof CommandRegistration\r\n   */\r\n  public createParams(parameters: ExecuteParameters, apiToPresLayer: ApiToPresLayerMappingRegistry): { [paramId: string]: object; } {\r\n    let result: { [paramId: string]: object; } = {};\r\n\r\n    for (const inputParam of this.inputs) {\r\n      // First make sure the parameter is there or that it's optional\r\n      if (!parameters.hasOwnProperty(inputParam.apiId)) {\r\n        if (inputParam.isOptional) {\r\n          continue;\r\n        } else {\r\n          throw TableauException.missingParameter([inputParam.apiId]);\r\n        }\r\n      }\r\n\r\n      // Find the conversion function for this parameter\r\n      const conversionFn = apiToPresLayer.get(inputParam.apiId, inputParam.presLayerId);\r\n\r\n      // Convert the pres model and insert it into our results object\r\n      result[inputParam.presLayerId] = conversionFn(parameters[inputParam.apiId]);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Processes the result received back after executing a pres-layer command\r\n   *\r\n   * @param {{ [docParamId: string]: object; }} resultParameters\r\n   * @param {PresLayerToApiMappingRegistry} presLayerToApi\r\n   * @returns {Model}\r\n   * @memberof CommandRegistration\r\n   */\r\n  public ProcessResult(resultParameters: { [docParamId: string]: object; }, presLayerToApi: PresLayerToApiMappingRegistry): Model {\r\n    // TODO: Add error handling\r\n    if (this.output === undefined) {\r\n      const noOutputModel: Model = {};\r\n      return noOutputModel;\r\n    }\r\n    if (!resultParameters || !resultParameters.hasOwnProperty(this.output.presLayerId)) {\r\n\r\n      // if the output result is marked as optional, we don't consider this an error situation and just return an empty model\r\n      if (this.output.isOptional) {\r\n        return {};\r\n      }\r\n      throw TableauException.missingParameter([this.output.presLayerId]);\r\n    }\r\n\r\n    const conversionFn = presLayerToApi.get(this.output.presLayerId, this.output.apiId);\r\n    return conversionFn(resultParameters[this.output.presLayerId]);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/CommandRegistration.ts\n **/","import { Model, NotificationId as Api, VersionNumber } from '@tableau/api-internal-contract';\r\n\r\nimport { NotificationId as PL } from '../../gen-src/preslayer/Events';\r\nimport { PresentationModel } from '../../gen-src/preslayer/PresModels';\r\nimport { PresLayerToApiConverter } from './PresLayerToApiConverter';\r\n\r\nexport type ConversionFn = (presModel: PresentationModel) => Model;\r\n\r\n/**\r\n * Simple wrapper which holds a mapping to go from a pres-layer event to an API event\r\n */\r\nexport class EventMappingRegistration {\r\n  public get presLayerId(): PL {\r\n    return this._presLayerId;\r\n  }\r\n\r\n  public get apiId(): Api {\r\n    return this._apiId;\r\n  }\r\n\r\n  public get converter(): ConversionFn {\r\n    return this._converter;\r\n  }\r\n\r\n  public constructor(\r\n    private _presLayerId: PL,\r\n    private _apiId: Api,\r\n    private _converter: ConversionFn) { }\r\n}\r\n\r\n/**\r\n * Simple type which has keys of PL event ids to EventMappingRegistrations\r\n */\r\nexport type EventMappingRegistry = { [key: string]: EventMappingRegistration; };\r\n\r\nexport class EventMappingRegistryFactory {\r\n  /**\r\n   * Creates and populates a new EventMappingRegistry for the specific version number requested\r\n   *\r\n   * @param {VersionNumber} versionNumber\r\n   * @returns {EventMappingRegistry}\r\n   */\r\n  public static createEventMappingRegistry(versionNumber: VersionNumber): EventMappingRegistry {\r\n    let registry: EventMappingRegistry = {};\r\n    registry[PL.SelectionChanged] = new EventMappingRegistration(\r\n      PL.SelectionChanged,\r\n      Api.SelectedMarksChanged,\r\n      PresLayerToApiConverter.convertVisualId\r\n    );\r\n\r\n    registry[PL.ParameterChanged] = new EventMappingRegistration(\r\n      PL.ParameterChanged,\r\n      Api.ParameterChanged,\r\n      PresLayerToApiConverter.convertFieldCaptionPair\r\n    );\r\n\r\n    registry[PL.FilterChanged] = new EventMappingRegistration(\r\n      PL.FilterChanged,\r\n      Api.FilterChanged,\r\n      PresLayerToApiConverter.convertFilterEvent\r\n    );\r\n\r\n    return registry;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/EventMappingRegistryFactory.ts\n **/","\r\n/* tslint:disable */\r\n// -----------------------------------------------------------------------------\r\n//\r\n// This file is the copyrighted property of Tableau Software and is protected\r\n// by registered patents and other applicable U.S. and international laws and\r\n// regulations.\r\n//\r\n// Unlicensed use of the contents of this file is prohibited. Please refer to\r\n// the NOTICES.txt file for further details.\r\n//\r\n// -----------------------------------------------------------------------------\r\n// WARNING: Computer generated file.  Do not hand modify.\r\n// DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/events-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-events.data', '../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/events-common.template']\r\n\r\n// Events you can register to receive presentation models\r\nexport enum NotificationId {\r\n\r\n  // Triggered when aliases are to be edited. Used to launch a dialog.\r\n  EditAliasesDialogNotification = 'doc:edit-aliases-dialog-notification-event',\r\n\r\n  // for the calculation dialog\r\n  CalculationDialog = 'doc:calculation-dialog-event',\r\n\r\n  // update for an adhoc calc in a type in pill\r\n  TypeInPill = 'doc:type-in-pill-event',\r\n\r\n  // results of a validation command\r\n  CommandValidation = 'doc:command-validation-event',\r\n\r\n  // event for the groups dialog\r\n  UpdateCategoricalBinEditDialog = 'doc:update-categorical-bin-edit-dialog-event',\r\n\r\n  // for the categorical color dialog\r\n  CategoricalColor = 'doc:categorical-color-event',\r\n\r\n  // update the web categorical color dialog\r\n  WebCategoricalColorDialog = 'doc:web-categorical-color-dialog-event',\r\n\r\n  // user invoked action which requires a Data Alert Dialog\r\n  DataAlertDialog = 'doc:data-alert-dialog-event',\r\n\r\n  // event to select field(s) in the data schema\r\n  DataSchemaSelection = 'doc:data-schema-selection-event',\r\n\r\n  // event for when the data source being edited is updated\r\n  UpdateDataPreparation = 'doc:update-data-preparation-event',\r\n\r\n  // event for when the data source data is updated\r\n  UpdateDataSourceData = 'doc:update-data-source-data-event',\r\n\r\n  // event for when a client should request new data source or data source data pres models\r\n  DataSourceUpdateNeeded = 'doc:data-source-update-needed-event',\r\n\r\n  // event for getting the pres model to update file join table properties\r\n  TextFileProperties = 'doc:text-file-properties-event',\r\n\r\n  // notify changes to the state of a filter's relational model\r\n  FilterRelationalStateChanged = 'doc:filter-relational-state-changed-event',\r\n\r\n  // notify changes to the size/selection count of a relational domain\r\n  FilterRelationalDomainChanged = 'doc:filter-relational-domain-changed-event',\r\n\r\n  // notify when filter cache was requested but not found\r\n  FilterCacheNotFound = 'doc:filter-cache-not-found-event',\r\n\r\n  // Hierarchy Select model observable notification.\r\n  HierarchyNotification = 'doc:hierarchy-notification-event',\r\n\r\n  // Hierarchy selection change notifications.\r\n  HierarchySelection = 'doc:hierarchy-selection-event',\r\n\r\n  // event for the map options dialog\r\n  MapOptionsDialog = 'doc:map-options-dialog-event',\r\n\r\n  // notify the Page UI(hide/show states, layout) needs to be updated\r\n  UpdatePageUINotification = 'doc:update-page-uinotification-event',\r\n\r\n  // notify to the SceneView has been drawn.\r\n  SceneViewDrawnNotification = 'doc:scene-view-drawn-notification-event',\r\n\r\n  // The AnimationControlChange event fires when the user clicks an animation playback button: forward, stop, slow, fast, etc.\r\n  AnimationControlChange = 'doc:animation-control-change-event',\r\n\r\n  // notify the sheet has been renamed\r\n  RenameSheetNotification = 'doc:rename-sheet-notification-event',\r\n\r\n  // update the web quantitative color dialog\r\n  WebQuantitativeColorDialog = 'doc:web-quantitative-color-dialog-event',\r\n\r\n  // update the button config dialog\r\n  UpdateButtonConfigDialog = 'doc:update-button-config-dialog-event',\r\n\r\n  // event for the reference line dialog, which is only valid during web authoring\r\n  UpdateRefLineDialog = 'doc:update-ref-line-dialog-event',\r\n\r\n  // event to trigger other reference line dialogs to close\r\n  RefLineDialogOpening = 'doc:ref-line-dialog-opening-event',\r\n\r\n  // event for the close data source error dialog, which is only valid during web authoring\r\n  CloseDataSourceErrorDialog = 'doc:close-data-source-error-dialog-event',\r\n\r\n  // update the web Save Datasource dialog\r\n  WebSaveDatasourceDialog = 'doc:web-save-datasource-dialog-event',\r\n\r\n  // warning resulting from WarningMsg\r\n  WarningMessage = 'doc:warning-message-event',\r\n\r\n  // event for the table calc dialog, on web, this is only valid during web authoring\r\n  TableCalcDialog = 'doc:table-calc-dialog-event',\r\n\r\n  // user invoked action which requires Table Calc Dialog\r\n  TableCalcActivateDialog = 'doc:table-calc-activate-dialog-event',\r\n\r\n  // event for the trend line dialog\r\n  UpdateTrendLineEditDialog = 'doc:update-trend-line-edit-dialog-event',\r\n\r\n  // The table page cache has been refreshed; pages must be reloaded from the cache.\r\n  PageCacheRefresh = 'doc:page-cache-refresh-event',\r\n\r\n  // The table page cache has expired and all resources have been released.\r\n  PageCacheExpired = 'doc:page-cache-expired-event',\r\n\r\n  // All pages, identified by row/col, in the provided list have expired and should be reloaded.\r\n  PageCachePagesExpired = 'doc:page-cache-pages-expired-event',\r\n\r\n  // All pages betweem the range (inclusive) in the provided list have expired and should be reloaded.\r\n  PageCachePageRangeExpired = 'doc:page-cache-page-range-expired-event',\r\n\r\n  // Triggered when the user wants to reload an add-in instance.\r\n  ReloadAddIn = 'doc:reload-add-in-event',\r\n\r\n  // Triggered when the selected marks have changed.\r\n  SelectionChanged = 'doc:selection-changed-event',\r\n\r\n  // Triggered when the value of a parameter has changed. Emits the name and caption of the parameter\r\n  ParameterChanged = 'doc:parameter-changed-event',\r\n\r\n  // Triggered when the filters have changed.\r\n  FilterChanged = 'doc:filter-changed-event',\r\n\r\n  // Triggered when saved cluster needs to be recalculated.\r\n  ClusterRefitNotification = 'doc:cluster-refit-notification-event',\r\n\r\n  // event for the detailed error dialog\r\n  UpdateDetailedErrorDialog = 'doc:update-detailed-error-dialog-event',\r\n\r\n  // update the axis edit dialog\r\n  UpdateEditAxisDialog = 'doc:update-edit-axis-dialog-event',\r\n\r\n  // notification to launch the hybrid UI showcase\r\n  LaunchHybridUIShowcase = 'doc:launch-hybrid-uishowcase-event',\r\n\r\n  // notification of new echoed text for HybridUI showcase demo\r\n  HybridUIShowcaseEcho = 'doc:hybrid-uishowcase-echo-event',\r\n\r\n  // event for the bin dialog\r\n  UpdateNumericBinEditDialog = 'doc:update-numeric-bin-edit-dialog-event',\r\n\r\n  // Update for the rich text editor dialog\r\n  RichTextEditorDialog = 'doc:rich-text-editor-dialog-event',\r\n\r\n  // event for the sort dialog\r\n  UpdateSortDialog = 'doc:update-sort-dialog-event',\r\n\r\n  // a test event with a pres model\r\n  TestEventWithModel = 'doc:test-event-with-model-event',\r\n\r\n  // a test event without a pres model\r\n  TestEventWithoutModel = 'doc:test-event-without-model-event'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/gen-src/preslayer/Events.ts\n **/","import * as Api from '@tableau/api-internal-contract';\r\nimport { Param } from '@tableau/api-utils';\r\n\r\nimport * as PresLayer from '../../gen-src/preslayer/PresModels';\r\nimport { PresLayerToApiEnumMappings as EnumMappings } from './EnumMappings';\r\n\r\n/**\r\n * Class containing helper methods for converting from PresLayerPresModels to their ApiPresModels equivalents\r\n *\r\n * @export\r\n * @class PresLayerToApiConverter\r\n */\r\nexport class PresLayerToApiConverter {\r\n  public static PARAMETERS_DB_NAME: string = 'Parameters';\r\n\r\n  public static convertSheetPath(plSheetPath: PresLayer.SheetPathPresModel): Api.SheetPath {\r\n    const result: Api.SheetPath = {\r\n      sheetName: plSheetPath.sheetName,\r\n      isDashboard: plSheetPath.isDashboard,\r\n      storyboard: plSheetPath.storyboard,\r\n      flipboardZoneID: plSheetPath.flipboardZoneId,\r\n      storyPointID: plSheetPath.storyPointId,\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertVisualId(plVisualId: PresLayer.VisualIDPresModel): Api.VisualId {\r\n    const result: Api.VisualId = {\r\n      worksheet: plVisualId.worksheet,\r\n      dashboard: plVisualId.dashboard,\r\n      storyboard: plVisualId.storyboard,\r\n      flipboardZoneID: plVisualId.flipboardZoneId,\r\n      storyPointID: plVisualId.storyPointId,\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionLocator(plAddInLocator: PresLayer.AddInLocatorPresModel): Api.ExtensionLocator {\r\n    let dashboardPath = undefined;\r\n    if (plAddInLocator.sheetPath) {\r\n      dashboardPath = PresLayerToApiConverter.convertSheetPath(plAddInLocator.sheetPath);\r\n    }\r\n\r\n    const result: Api.ExtensionLocator = {\r\n      instanceId: plAddInLocator.addInInstanceId,\r\n      dashboardPath: dashboardPath\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertDashboardInZones(plDashboard: PresLayer.DashboardPresModel): Array<Api.DashboardZone> {\r\n    const result = new Array<Api.DashboardZone>();\r\n\r\n    for (const zoneKey of Object.keys(plDashboard.zones)) {\r\n      const zone = plDashboard.zones[zoneKey];\r\n      let apiZone: Api.DashboardZone = {\r\n        name: zone.zoneCommon.name,\r\n        zoneId: zone.zoneId,\r\n        zoneType: EnumMappings.zoneType.convert(zone.zoneCommon.zoneType),\r\n        height: zone.zoneCommon.h,\r\n        width: zone.zoneCommon.w,\r\n        x: zone.zoneCommon.x,\r\n        y: zone.zoneCommon.y\r\n      };\r\n\r\n      result.push(apiZone);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertDashboardInfo(plDashboardInfo: PresLayer.AddInDashboardInfoPresModel): Api.ExtensionDashboardInfo {\r\n    const result: Api.ExtensionDashboardInfo = {\r\n      zones: PresLayerToApiConverter.convertDashboardInZones(plDashboardInfo.dashboardPresModel),\r\n      name: plDashboardInfo.dashboardPresModel.sheetPath.sheetName,\r\n      extensionZoneId: plDashboardInfo.zoneId,\r\n      size: plDashboardInfo.dashboardPresModel.viewportSize\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionInstance(plAddInInstance: PresLayer.AddInInstancePresModel): Api.ExtensionInstance {\r\n    const result: Api.ExtensionInstance = {\r\n      url: plAddInInstance.addInRegistrationPresModel.url,\r\n      locator: PresLayerToApiConverter.convertExtensionLocator(plAddInInstance.addInLocatorPresModel)\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionEnivrionment(plAddInEnvironment: PresLayer.AddInEnvironmentPresModel): Api.ExtensionEnvironment {\r\n    const result: Api.ExtensionEnvironment = {\r\n      extensionContext: EnumMappings.extensionContext.convert(plAddInEnvironment.addInContext),\r\n      extensionMode: EnumMappings.extensionMode.convert(plAddInEnvironment.addInMode),\r\n      extensionLocale: plAddInEnvironment.addInLocale,\r\n      extensionLanguage: plAddInEnvironment.addInLanguage,\r\n      tableauVersion: plAddInEnvironment.tableauVersion,\r\n      operatingSystem: plAddInEnvironment.operatingSystem,\r\n      apiVersion: plAddInEnvironment.apiVersion\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionSettingsInfo(plAddInSettings: PresLayer.AddInSettingsInfoPresModel): Api.ExtensionSettingsInfo {\r\n    const result: Api.ExtensionSettingsInfo = {\r\n      // addInSettings is undefined during bootstrap initialization\r\n      settingsValues: plAddInSettings.addInSettings || {}\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionBootstrapInfo(plBootstrapInfo: PresLayer.AddInBootstrapInfoPresModel): Api.ExtensionBootstrapInfo {\r\n    const result: Api.ExtensionBootstrapInfo = {\r\n      extensionDashboardInfo: PresLayerToApiConverter.convertDashboardInfo(plBootstrapInfo.addInDashboardInfoPresModel),\r\n      extensionEnvironment: PresLayerToApiConverter.convertExtensionEnivrionment(plBootstrapInfo.addInEnvironmentPresModel),\r\n      extensionInstance: PresLayerToApiConverter.convertExtensionInstance(plBootstrapInfo.addInInstancePresModel),\r\n      extensionSettingsInfo: PresLayerToApiConverter.convertExtensionSettingsInfo(plBootstrapInfo.addInSettingsInfo)\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertFieldCaptionPair(plFieldCaptionPair: PresLayer.FieldCaptionPairPresModel): string {\r\n    return plFieldCaptionPair.fn;\r\n  }\r\n\r\n  public static convertFilterEvent(plFilterEvent: PresLayer.FilterChangeEventPresModel): Api.FilterEvent {\r\n    const result: Api.FilterEvent = {\r\n      visualId: PresLayerToApiConverter.convertVisualId(plFilterEvent.visualIdPresModel),\r\n      fieldName: plFilterEvent.fieldCaption\r\n    };\r\n    return result;\r\n  }\r\n\r\n  public static convertDataSchema(dataSchema: PresLayer.DataSchemaPresModel): Api.DataSchema {\r\n    let apiDataSources: Api.DataSourceMap = { };\r\n\r\n    Param.verifyValue(dataSchema, 'dataSchema');\r\n    Param.verifyValue(dataSchema.dataSources, 'dataSchema.dataSources');\r\n\r\n    // Convert each pres layer datasource in the schema to an Api datasource\r\n    Object.keys(dataSchema.dataSources).forEach((key) => {\r\n      // Skip the default Parameters datasource we receive from the platform.\r\n      if (dataSchema.dataSources[key].datasource !== PresLayerToApiConverter.PARAMETERS_DB_NAME) {\r\n        apiDataSources[key] = PresLayerToApiConverter.convertDataSource(dataSchema.dataSources[key]);\r\n      }\r\n    });\r\n\r\n    const schemaMap = PresLayerToApiConverter.convertWorksheetDataSchemaMap(dataSchema.worksheetDataSchemaMap);\r\n\r\n    const result: Api.DataSchema = {\r\n      dataSources: apiDataSources,\r\n      worksheetDataSchemaMap: schemaMap,\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertDataSource(dataSource: PresLayer.DataSourcePresModel): Api.DataSource {\r\n    const extractUpdateTime = (dataSource.extractUpdateTime === '') ? undefined : dataSource.extractUpdateTime;\r\n    const dataSourceFields = new Array<Api.Field>();\r\n\r\n    Param.verifyValue(dataSource, 'dataSource');\r\n    Param.verifyValue(dataSource.fieldList, 'dataSchema.fieldList');\r\n\r\n    dataSource.fieldList.forEach((plField) => {\r\n      // If the datasource contains hierarchies or folders, the base field will contain\r\n      // a list of the fields grouped beneath it, we are interested in those.\r\n      // Tableau does not support nested folders or hierarchies, so this does not need to be recursive.\r\n      const hierarchyModel = plField as PresLayer.HierarchyPresModel;\r\n\r\n      if (hierarchyModel.columnList) { // If column list is defined, this is a hierarchy.\r\n        hierarchyModel.columnList.forEach(field => dataSourceFields.push(PresLayerToApiConverter.convertField(field)));\r\n      } else {\r\n        // This is a bit brittle for now, but this value is not exposed via the platform FieldType Enum.\r\n        if (plField.type !== 'field-folder' && plField.type !== 'dimension') {\r\n          dataSourceFields.push(PresLayerToApiConverter.convertField(plField));\r\n        }\r\n      }\r\n    });\r\n\r\n    const result: Api.DataSource = {\r\n      name: dataSource.datasourceCaption,\r\n      id: dataSource.datasource,\r\n      isExtract: (extractUpdateTime !== undefined),\r\n      extractUpdateTime: extractUpdateTime,\r\n      fields: dataSourceFields\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertWorksheetDataSchemaMap(schemaMap: { [key: string]: PresLayer.WorksheetDataSchemaPresModel }):\r\n    Api.WorksheetDataSchemaMap {\r\n\r\n    let result: Api.WorksheetDataSchemaMap = {};\r\n\r\n    Object.keys(schemaMap).forEach((key) => {\r\n      // We need to remove any references to the \"Parameters\" datasource.  This is treated as a separate\r\n      // datasource by the platform, but the Extensions API accesses Parameters directly.\r\n      let cleanReferencedDataSourceList = schemaMap[key].referencedDataSourceList.filter((dsName) => {\r\n        return dsName !== PresLayerToApiConverter.PARAMETERS_DB_NAME;\r\n      });\r\n\r\n      const worksheetDataSourceInfo: Api.WorksheetDataSourceInfo = {\r\n        primaryDataSource: schemaMap[key].primaryDatasource,\r\n        referencedDataSourceList: cleanReferencedDataSourceList\r\n      };\r\n\r\n      result[key] = worksheetDataSourceInfo;\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertField(plField: PresLayer.FieldPresModel): Api.Field {\r\n    const fieldColumn = plField as PresLayer.FieldColumnPresModel;\r\n    const groupColumn = plField as PresLayer.GroupPresModel;\r\n\r\n    let aggregation = Api.FieldAggregationType.None;\r\n    let role = Api.FieldRoleType.Unknown;\r\n    let isCalculated = false;\r\n\r\n    // We expect that every FieldPresModel we get back from the command that returns FieldPresModels\r\n    // is actually an instance of the derived FieldColumnPresModel.\r\n    if (fieldColumn.aggregation && fieldColumn.fieldRole) {\r\n      aggregation = EnumMappings.fieldAggregationType.convert(fieldColumn.aggregation);\r\n      role = EnumMappings.fieldRoleType.convert(fieldColumn.fieldRole);\r\n      isCalculated = fieldColumn.isCalculated || false;\r\n    } else {\r\n      throw new Error('Unexpected Internal Error: field pres model is missing expected properties.');\r\n    }\r\n\r\n    const result: Api.Field = {\r\n      name: plField.description,\r\n      id: plField.name,\r\n      description: plField.userCaption,\r\n      aggregation: aggregation,\r\n      isHidden: !!(plField.isHidden),\r\n      isGenerated: plField.isGenerated,\r\n      isCalculatedField: isCalculated,\r\n      role: role,\r\n      isCombinedField: !!(groupColumn.isCombinedField)\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertJoinDescription(plJoinDescription: PresLayer.JoinDescriptionPresModel): Api.JoinDescription {\r\n    Param.verifyValue(plJoinDescription, 'plJoinDescription');\r\n    let apiTables: Api.TableInfo[] = plJoinDescription.joinTableInfos.map(joinTable => {\r\n      const apiTable: Api.TableInfo = {\r\n        name: joinTable.tableAlias,\r\n        id: joinTable.tableName,\r\n        customSQL: (joinTable.isCustomSql) ? joinTable.sqlQuery : undefined,\r\n        connectionClassName: joinTable.connectionClassName,\r\n        connectionId: joinTable.connectionName\r\n      };\r\n\r\n      return apiTable;\r\n    });\r\n\r\n    const result: Api.JoinDescription = {\r\n      tables: apiTables\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertConnectionDescrptionSummaries(plConnectionDescription: PresLayer.ConnectionDescriptionSummaryPresModel[]):\r\n    Api.ConnectionDescriptionSummary[] {\r\n    return plConnectionDescription.map(plSummary => {\r\n      const apiConnection: Api.ConnectionDescriptionSummary = {\r\n        name: plSummary.connectionDescriptionLabel,\r\n        id: plSummary.connectionName,\r\n        type: plSummary.connectionTypeLabel,\r\n        serverURI: plSummary.connectionUri\r\n      };\r\n\r\n      return apiConnection;\r\n    });\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/PresLayerToApiConverter.ts\n **/","import {\r\n  DashboardObjectType,\r\n  DataType,\r\n  DateRangeType,\r\n  DateStepPeriod,\r\n  DomainRestrictionType,\r\n  ExtensionContext,\r\n  ExtensionMode,\r\n  FieldAggregationType,\r\n  FieldRoleType,\r\n  FilterDomainType,\r\n  FilterNullOption,\r\n  FilterUpdateType\r\n} from '@tableau/api-internal-contract';\r\nimport { EnumConverter } from '@tableau/api-utils';\r\n\r\nimport * as Enums from '../../gen-src/preslayer/Enums';\r\n\r\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\r\nexport class PresLayerToApiEnumMappings {\r\n  public static zoneType = new EnumConverter<Enums.ZoneType, DashboardObjectType>({\r\n    [Enums.ZoneType.ZT_Invalid]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_Viz]: DashboardObjectType.Worksheet,\r\n    [Enums.ZoneType.ZT_ColorLegend]: DashboardObjectType.Legend,\r\n    [Enums.ZoneType.ZT_ShapeLegend]: DashboardObjectType.Legend,\r\n    [Enums.ZoneType.ZT_SizeLegend]: DashboardObjectType.Legend,\r\n    [Enums.ZoneType.ZT_MapLegend]: DashboardObjectType.Legend,\r\n    [Enums.ZoneType.ZT_QuickFilter]: DashboardObjectType.QuickFilter,\r\n    [Enums.ZoneType.ZT_Highlighter]: DashboardObjectType.Blank, // TODO\r\n    [Enums.ZoneType.ZT_CurrPage]: DashboardObjectType.PageFilter,\r\n    [Enums.ZoneType.ZT_Empty]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_Title]: DashboardObjectType.Title,\r\n    [Enums.ZoneType.ZT_Text]: DashboardObjectType.Text,\r\n    [Enums.ZoneType.ZT_Bitmap]: DashboardObjectType.Image,\r\n    [Enums.ZoneType.ZT_Web]: DashboardObjectType.WebPage,\r\n    [Enums.ZoneType.ZT_AddIn]: DashboardObjectType.Extension, // TODO\r\n    [Enums.ZoneType.ZT_ParamCtrl]: DashboardObjectType.ParameterControl,\r\n    [Enums.ZoneType.ZT_FlipboardNav]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_Flipboard]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_LayoutBasic]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_LayoutFlow]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_LayoutFreeForm]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_End]: DashboardObjectType.Blank,\r\n    [Enums.ZoneType.ZT_Button]: DashboardObjectType.Blank,\r\n  }, DashboardObjectType.Blank);\r\n\r\n  public static extensionContext = new EnumConverter<Enums.AddInContext, ExtensionContext>({\r\n    [Enums.AddInContext.Unknown]: ExtensionContext.Unknown,\r\n    [Enums.AddInContext.Desktop]: ExtensionContext.Desktop,\r\n    [Enums.AddInContext.Server]: ExtensionContext.Server\r\n  });\r\n\r\n  public static extensionMode = new EnumConverter<Enums.AddInMode, ExtensionMode>({\r\n    [Enums.AddInMode.Unknown]: ExtensionMode.Unknown,\r\n    [Enums.AddInMode.Authoring]: ExtensionMode.Authoring,\r\n    [Enums.AddInMode.Viewing]: ExtensionMode.Viewing\r\n  });\r\n\r\n  public static dataType = new EnumConverter<Enums.DataType, DataType> ({\r\n    [Enums.DataType.DT_BOOLEAN]: DataType.Bool,\r\n    [Enums.DataType.DT_DATE]: DataType.Date,\r\n    [Enums.DataType.DT_DATETIME]: DataType.DateTime,\r\n    [Enums.DataType.DT_INTEGER]: DataType.Int,\r\n    [Enums.DataType.DT_REAL]: DataType.Float,\r\n    [Enums.DataType.DT_STRING]: DataType.String,\r\n    [Enums.DataType.DT_SPATIAL]: DataType.Spatial\r\n  });\r\n\r\n  public static fieldAggregationType = new EnumConverter<Enums.AggType, FieldAggregationType>({\r\n    [Enums.AggType.AGG_ATTR]: FieldAggregationType.Attr,\r\n    [Enums.AggType.AGG_AVG]: FieldAggregationType.Avg,\r\n    [Enums.AggType.AGG_COUNT]: FieldAggregationType.Count,\r\n    [Enums.AggType.AGG_COUNTD]: FieldAggregationType.Countd,\r\n    [Enums.AggType.AGG_DAY]: FieldAggregationType.Day,\r\n    [Enums.AggType.AGG_END]: FieldAggregationType.End,\r\n    [Enums.AggType.AGG_HOUR]: FieldAggregationType.Hour,\r\n    [Enums.AggType.AGG_INOUT]: FieldAggregationType.InOut,\r\n    [Enums.AggType.AGG_KURTOSIS]: FieldAggregationType.Kurtosis,\r\n    [Enums.AggType.AGG_MAX]: FieldAggregationType.Max,\r\n    [Enums.AggType.AGG_MDY]: FieldAggregationType.Mdy,\r\n    [Enums.AggType.AGG_MEDIAN]: FieldAggregationType.Median,\r\n    [Enums.AggType.AGG_MIN]: FieldAggregationType.Min,\r\n    [Enums.AggType.AGG_MINUTE]: FieldAggregationType.Minute,\r\n    [Enums.AggType.AGG_MONTHYEAR]: FieldAggregationType.MonthYear,\r\n    [Enums.AggType.AGG_NONE]: FieldAggregationType.None,\r\n    [Enums.AggType.AGG_QTR]: FieldAggregationType.Qtr,\r\n    [Enums.AggType.AGG_QUART1]: FieldAggregationType.Quart1,\r\n    [Enums.AggType.AGG_QUART3]: FieldAggregationType.Quart3,\r\n    [Enums.AggType.AGG_SECOND]: FieldAggregationType.Second,\r\n    [Enums.AggType.AGG_SKEWNESS]: FieldAggregationType.Skewness,\r\n    [Enums.AggType.AGG_STDEV]: FieldAggregationType.Stdev,\r\n    [Enums.AggType.AGG_STDEVP]: FieldAggregationType.Stdevp,\r\n    [Enums.AggType.AGG_SUM]: FieldAggregationType.Sum,\r\n    [Enums.AggType.TRUNC_DAY]: FieldAggregationType.TruncDay,\r\n    [Enums.AggType.TRUNC_HOUR]: FieldAggregationType.TruncHour,\r\n    [Enums.AggType.TRUNC_MINUTE]: FieldAggregationType.TruncMinute,\r\n    [Enums.AggType.TRUNC_MONTH]: FieldAggregationType.TruncMonth,\r\n    [Enums.AggType.TRUNC_QTR]: FieldAggregationType.TruncQtr,\r\n    [Enums.AggType.TRUNC_SECOND]: FieldAggregationType.TruncSecond,\r\n    [Enums.AggType.TRUNC_WEEK]: FieldAggregationType.TruncWeek,\r\n    [Enums.AggType.TRUNC_YEAR]: FieldAggregationType.TruncYear,\r\n    [Enums.AggType.AGG_USER]: FieldAggregationType.User,\r\n    [Enums.AggType.AGG_VAR]: FieldAggregationType.Var,\r\n    [Enums.AggType.AGG_VARP]: FieldAggregationType.Varp,\r\n    [Enums.AggType.AGG_WEEK]: FieldAggregationType.Week,\r\n    [Enums.AggType.AGG_WEEKDAY]: FieldAggregationType.Weekday,\r\n    [Enums.AggType.AGG_YEAR]: FieldAggregationType.Year,\r\n  });\r\n\r\n  public static fieldRoleType = new EnumConverter<Enums.FieldRole, FieldRoleType>({\r\n    [Enums.FieldRole.ROLE_DIMENSION]: FieldRoleType.Dimension,\r\n    [Enums.FieldRole.ROLE_MEASURE]: FieldRoleType.Measure\r\n  });\r\n\r\n  public static parameterTypesDomainType = new EnumConverter<Enums.ParameterTypesDomainType, DomainRestrictionType>({\r\n    [Enums.ParameterTypesDomainType.Domain_Any]: DomainRestrictionType.All,\r\n    [Enums.ParameterTypesDomainType.Domain_List]: DomainRestrictionType.List,\r\n    [Enums.ParameterTypesDomainType.Domain_Range]: DomainRestrictionType.Range,\r\n  });\r\n\r\n  public static dateStepPeriod = new EnumConverter<Enums.DatePeriodType, DateStepPeriod>({\r\n    [Enums.DatePeriodType.PeriodYear]: DateStepPeriod.Years,\r\n    [Enums.DatePeriodType.PeriodQuarter]: DateStepPeriod.Quarters,\r\n    [Enums.DatePeriodType.PeriodMonth]: DateStepPeriod.Months,\r\n    [Enums.DatePeriodType.PeriodWeek]: DateStepPeriod.Weeks,\r\n    [Enums.DatePeriodType.PeriodDay]: DateStepPeriod.Days,\r\n    [Enums.DatePeriodType.PeriodHour]: DateStepPeriod.Hours,\r\n    [Enums.DatePeriodType.PeriodMinute]: DateStepPeriod.Minutes,\r\n    [Enums.DatePeriodType.PeriodSecond]: DateStepPeriod.Seconds\r\n  });\r\n\r\n  public static dateRangeType = new EnumConverter<Enums.FiltersRelativeDateRangeType, DateRangeType>({\r\n    [Enums.FiltersRelativeDateRangeType.RangeCurrent]: DateRangeType.Current,\r\n    [Enums.FiltersRelativeDateRangeType.RangeCurrentToDate]: DateRangeType.ToDate,\r\n    [Enums.FiltersRelativeDateRangeType.RangeLast1]: DateRangeType.Last,\r\n    [Enums.FiltersRelativeDateRangeType.RangeLastN]: DateRangeType.LastN,\r\n    [Enums.FiltersRelativeDateRangeType.RangeNext1]: DateRangeType.Next,\r\n    [Enums.FiltersRelativeDateRangeType.RangeNextN]: DateRangeType.NextN\r\n  });\r\n\r\n  public static filterDomainType = new EnumConverter<Enums.FiltersDomainType, FilterDomainType> ({\r\n    [Enums.FiltersDomainType.Relevant]: FilterDomainType.Relevant,\r\n    [Enums.FiltersDomainType.Database]: FilterDomainType.Database\r\n  });\r\n}\r\n\r\nexport class ApiToPresLayerEnumMappings {\r\n  public static filterUpdateType = new EnumConverter<FilterUpdateType, Enums.FilterUpdateType> ({\r\n    [FilterUpdateType.Add]: Enums.FilterUpdateType.ADD,\r\n    [FilterUpdateType.All]: Enums.FilterUpdateType.ALL,\r\n    [FilterUpdateType.Replace]: Enums.FilterUpdateType.REPLACE,\r\n    [FilterUpdateType.Remove]: Enums.FilterUpdateType.REMOVE\r\n  });\r\n\r\n  public static nullOption = new EnumConverter<FilterNullOption, Enums.FiltersQuantitativeIncludedValues> ({\r\n    [FilterNullOption.AllValues]: Enums.FiltersQuantitativeIncludedValues.All,\r\n    [FilterNullOption.NonNullValues]: Enums.FiltersQuantitativeIncludedValues.NonNull,\r\n    [FilterNullOption.NullValues]: Enums.FiltersQuantitativeIncludedValues.Null\r\n  });\r\n\r\n  public static filterDomainType = new EnumConverter<FilterDomainType, Enums.FiltersDomainType> ({\r\n    [FilterDomainType.Relevant]: Enums.FiltersDomainType.Relevant,\r\n    [FilterDomainType.Database]: Enums.FiltersDomainType.Database\r\n  });\r\n}\r\n/* tslint:enable:typedef */\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/EnumMappings.ts\n **/","/* tslint:disable */\r\n// -----------------------------------------------------------------------------\r\n//\r\n// This file is the copyrighted property of Tableau Software and is protected\r\n// by registered patents and other applicable U.S. and international laws and\r\n// regulations.\r\n//\r\n// Unlicensed use of the contents of this file is prohibited. Please refer to\r\n// the NOTICES.txt file for further details.\r\n//\r\n// -----------------------------------------------------------------------------\r\n// WARNING: Computer generated file.  Do not hand modify.\r\n// DEPENDS ON: ['../typescript/js-api/api-core/node_modules/@tableau/preslayer-codegen-typescript/templates/enum-ts.template', u'../typescript/js-api/api-core/temp-pres-layer/all-enums.data']\r\n\r\n// \r\nexport enum DataScaling {\r\n\r\n  // \r\n  SCALING_NONE = 'none',\r\n\r\n  // \r\n  SCALING_STANDARDIZED = 'standardized',\r\n\r\n  // \r\n  SCALING_NORMALIZED = 'normalized'\r\n}\r\n\r\n// \r\nexport enum ForecastModelType {\r\n\r\n  // \r\n  ForecastModelTypeAutoSeason = 'auto-season',\r\n\r\n  // \r\n  ForecastModelTypeAuto = 'auto',\r\n\r\n  // \r\n  ForecastModelTypeCustom = 'custom'\r\n}\r\n\r\n// \r\nexport enum ForecastRangeType {\r\n\r\n  // \r\n  ForecastRangeTypeAuto = 'auto',\r\n\r\n  // \r\n  ForecastRangeTypeNext = 'next',\r\n\r\n  // \r\n  ForecastRangeTypeEndOf = 'end-of'\r\n}\r\n\r\n// \r\nexport enum ForecastStatus {\r\n\r\n  // \r\n  FS_VALID = 'fs-valid',\r\n\r\n  // \r\n  FS_INVALID_DATETIME = 'fs-invalid-datetime',\r\n\r\n  // \r\n  FS_INVALID_RESPONSE = 'fs-invalid-response',\r\n\r\n  // \r\n  FS_NEED_MORE_DATA = 'fs-need-more-data',\r\n\r\n  // \r\n  FS_TIME_SERIES_TOO_SHORT = 'fs-time-series-too-short',\r\n\r\n  // \r\n  FS_TIME_SERIES_IRREGULAR = 'fs-time-series-irregular',\r\n\r\n  // \r\n  FS_NULL_DATETIME = 'fs-null-datetime',\r\n\r\n  // \r\n  FS_NULL_RESPONSE = 'fs-null-response',\r\n\r\n  // \r\n  FS_METADATA_INVALID = 'fs-metadata-invalid',\r\n\r\n  // \r\n  FS_NO_RESPONSE = 'fs-no-response',\r\n\r\n  // \r\n  FS_EXCESS_DATA = 'fs-excess-data',\r\n\r\n  // \r\n  FS_EXCESS_PARTITIONS = 'fs-excess-partitions',\r\n\r\n  // \r\n  FS_DIMENSION_INVALID = 'fs-dimension-invalid',\r\n\r\n  // \r\n  FS_TABLECALC_INVALID = 'fs-tablecalc-invalid',\r\n\r\n  // \r\n  FS_TIME_SERIES_TOO_IRREGULAR = 'fs-time-series-too-irregular',\r\n\r\n  // \r\n  FS_AGGREGATE_FILTER = 'fs-aggregate-filter',\r\n\r\n  // \r\n  FS_DISAGGREGATE_RESPONSE = 'fs-disaggregate-response',\r\n\r\n  // \r\n  FS_PERCENTAGE_INVALID = 'fs-percentage-invalid',\r\n\r\n  // \r\n  FS_TOTAL_INVALID = 'fs-total-invalid',\r\n\r\n  // \r\n  FS_EXCESS_DATETIME = 'fs-excess-datetime',\r\n\r\n  // \r\n  FS_DATE_AGG_INCOMPATIBLE = 'fs-date-agg-incompatible',\r\n\r\n  // \r\n  FS_TIME_SERIES_NOT_POSITIVE = 'fs-time-series-not-positive',\r\n\r\n  // \r\n  FS_REQUESTED_MODEL_INVALID = 'fs-requested-model-invalid',\r\n\r\n  // \r\n  FS_TOO_SHORT_FOR_SEASON = 'fs-too-short-for-season',\r\n\r\n  // \r\n  FS_REQUESTED_MODEL_UNSTABLE = 'fs-requested-model-unstable',\r\n\r\n  // \r\n  FS_UNDEFINED = 'fs-undefined'\r\n}\r\n\r\n// \r\nexport enum StyleAttribute {\r\n\r\n  // \r\n  saAlternateText = 'saAlternateText',\r\n\r\n  // \r\n  saAltMarkColor = 'saAltMarkColor',\r\n\r\n  // \r\n  saAspect = 'saAspect',\r\n\r\n  // \r\n  saAutoSubtitle = 'saAutoSubtitle',\r\n\r\n  // \r\n  saBackgroundColor = 'saBackgroundColor',\r\n\r\n  // \r\n  saBackgroundTransparency = 'saBackgroundTransparency',\r\n\r\n  // \r\n  saBandSize = 'saBandSize',\r\n\r\n  // \r\n  saBandColor = 'saBandColor',\r\n\r\n  // \r\n  saBandLevel = 'saBandLevel',\r\n\r\n  // \r\n  saBodyType = 'saBodyType',\r\n\r\n  // \r\n  saBorderColor = 'saBorderColor',\r\n\r\n  // \r\n  saBorderColorTop = 'saBorderColorTop',\r\n\r\n  // \r\n  saBorderColorRight = 'saBorderColorRight',\r\n\r\n  // \r\n  saBorderColorBottom = 'saBorderColorBottom',\r\n\r\n  // \r\n  saBorderColorLeft = 'saBorderColorLeft',\r\n\r\n  // \r\n  saBorderStyle = 'saBorderStyle',\r\n\r\n  // \r\n  saBorderStyleTop = 'saBorderStyleTop',\r\n\r\n  // \r\n  saBorderStyleRight = 'saBorderStyleRight',\r\n\r\n  // \r\n  saBorderStyleBottom = 'saBorderStyleBottom',\r\n\r\n  // \r\n  saBorderStyleLeft = 'saBorderStyleLeft',\r\n\r\n  // \r\n  saBorderWidth = 'saBorderWidth',\r\n\r\n  // \r\n  saBorderWidthTop = 'saBorderWidthTop',\r\n\r\n  // \r\n  saBorderWidthRight = 'saBorderWidthRight',\r\n\r\n  // \r\n  saBorderWidthBottom = 'saBorderWidthBottom',\r\n\r\n  // \r\n  saBorderWidthLeft = 'saBorderWidthLeft',\r\n\r\n  // \r\n  saBoxplotStyle = 'saBoxplotStyle',\r\n\r\n  // \r\n  saBreakOnSpecial = 'saBreakOnSpecial',\r\n\r\n  // \r\n  saCell = 'saCell',\r\n\r\n  // \r\n  saCellW = 'saCellW',\r\n\r\n  // \r\n  saCellH = 'saCellH',\r\n\r\n  // \r\n  saCellQ = 'saCellQ',\r\n\r\n  // \r\n  saCellQMark = 'saCellQMark',\r\n\r\n  // \r\n  saColor = 'saColor',\r\n\r\n  // \r\n  saColorMode = 'saColorMode',\r\n\r\n  // \r\n  saColLevels = 'saColLevels',\r\n\r\n  // \r\n  saColVertLevels = 'saColVertLevels',\r\n\r\n  // \r\n  saColHorizHeight = 'saColHorizHeight',\r\n\r\n  // \r\n  saColVertHeight = 'saColVertHeight',\r\n\r\n  // Deprecated\r\n  saColHeight = 'saColHeight',\r\n\r\n  // \r\n  saColWidth = 'saColWidth',\r\n\r\n  // \r\n  saContent = 'saContent',\r\n\r\n  // \r\n  saDisplayFieldLabels = 'saDisplayFieldLabels',\r\n\r\n  // \r\n  saDisplayHeader = 'saDisplayHeader',\r\n\r\n  // \r\n  saDisplayAlternateText = 'saDisplayAlternateText',\r\n\r\n  // \r\n  saDivLevel = 'saDivLevel',\r\n\r\n  // \r\n  saEnabled = 'saEnabled',\r\n\r\n  // \r\n  saFillAboveColor = 'saFillAboveColor',\r\n\r\n  // \r\n  saFillBelowColor = 'saFillBelowColor',\r\n\r\n  // \r\n  saFillColor = 'saFillColor',\r\n\r\n  // \r\n  saFogBGColor = 'saFogBGColor',\r\n\r\n  // \r\n  saFogDesaturationWithoutSelection = 'saFogDesaturationWithoutSelection',\r\n\r\n  // \r\n  saFogDesaturationWithSelection = 'saFogDesaturationWithSelection',\r\n\r\n  // \r\n  saFont = 'saFont',\r\n\r\n  // \r\n  saFontFamily = 'saFontFamily',\r\n\r\n  // \r\n  saFontSize = 'saFontSize',\r\n\r\n  // \r\n  saFontStyle = 'saFontStyle',\r\n\r\n  // \r\n  saFontWeight = 'saFontWeight',\r\n\r\n  // \r\n  saGeographicAreaType = 'saGeographicAreaType',\r\n\r\n  // \r\n  saHAlign = 'saHAlign',\r\n\r\n  // \r\n  saHaloColor = 'saHaloColor',\r\n\r\n  // \r\n  saHaloColorSelected = 'saHaloColorSelected',\r\n\r\n  // \r\n  saHasFill = 'saHasFill',\r\n\r\n  // \r\n  saHasHalo = 'saHasHalo',\r\n\r\n  // Deprecated\r\n  saHasLabel = 'saHasLabel',\r\n\r\n  // \r\n  saHasStroke = 'saHasStroke',\r\n\r\n  // \r\n  saHeight = 'saHeight',\r\n\r\n  // \r\n  saHeightHeader = 'saHeightHeader',\r\n\r\n  // \r\n  saHighlightLegend = 'saHighlightLegend',\r\n\r\n  // \r\n  saHnaxis = 'saHnaxis',\r\n\r\n  // \r\n  saHnlabel = 'saHnlabel',\r\n\r\n  // \r\n  saInTooltip = 'saInTooltip',\r\n\r\n  // \r\n  saLineEnd = 'saLineEnd',\r\n\r\n  // \r\n  saLineEndSize = 'saLineEndSize',\r\n\r\n  // \r\n  saLineInterpolation = 'saLineInterpolation',\r\n\r\n  // \r\n  saLineMarkerPosition = 'saLineMarkerPosition',\r\n\r\n  // \r\n  saLinePattern = 'saLinePattern',\r\n\r\n  // \r\n  saLinePatternOnly = 'saLinePatternOnly',\r\n\r\n  // \r\n  saLineVisibility = 'saLineVisibility',\r\n\r\n  // \r\n  saMap = 'saMap',\r\n\r\n  // \r\n  saMapStyle = 'saMapStyle',\r\n\r\n  // \r\n  saMargin = 'saMargin',\r\n\r\n  // \r\n  saMarginTop = 'saMarginTop',\r\n\r\n  // \r\n  saMarginRight = 'saMarginRight',\r\n\r\n  // \r\n  saMarginBottom = 'saMarginBottom',\r\n\r\n  // \r\n  saMarginLeft = 'saMarginLeft',\r\n\r\n  // \r\n  saMarkColor = 'saMarkColor',\r\n\r\n  // \r\n  saMarkTransparency = 'saMarkTransparency',\r\n\r\n  // \r\n  saMarkLabelsShow = 'saMarkLabelsShow',\r\n\r\n  // \r\n  saRunningOrderLabelsShow = 'saRunningOrderLabelsShow',\r\n\r\n  // \r\n  saMarkLabelsMode = 'saMarkLabelsMode',\r\n\r\n  // \r\n  saMarkLabelsCull = 'saMarkLabelsCull',\r\n\r\n  // \r\n  saMarkLabelsLineEndFirst = 'saMarkLabelsLineEndFirst',\r\n\r\n  // \r\n  saMarkLabelsLineEndLast = 'saMarkLabelsLineEndLast',\r\n\r\n  // \r\n  saMarkLabelsRangeMin = 'saMarkLabelsRangeMin',\r\n\r\n  // \r\n  saMarkLabelsRangeMax = 'saMarkLabelsRangeMax',\r\n\r\n  // \r\n  saMarkLabelsRangeScope = 'saMarkLabelsRangeScope',\r\n\r\n  // \r\n  saMarkLabelsRangeField = 'saMarkLabelsRangeField',\r\n\r\n  // \r\n  saMarkMarkersMode = 'saMarkMarkersMode',\r\n\r\n  // \r\n  saMaxHeight = 'saMaxHeight',\r\n\r\n  // \r\n  saMaxFontSize = 'saMaxFontSize',\r\n\r\n  // \r\n  saMaxStrokeWidth = 'saMaxStrokeWidth',\r\n\r\n  // \r\n  saMaxWidth = 'saMaxWidth',\r\n\r\n  // \r\n  saMidStrokeWidth = 'saMidStrokeWidth',\r\n\r\n  // \r\n  saMinHeight = 'saMinHeight',\r\n\r\n  // \r\n  saMinFontSize = 'saMinFontSize',\r\n\r\n  // \r\n  saMinLength = 'saMinLength',\r\n\r\n  // \r\n  saMinMapSize = 'saMinMapSize',\r\n\r\n  // \r\n  saMinSize = 'saMinSize',\r\n\r\n  // \r\n  saMinStrokeWidth = 'saMinStrokeWidth',\r\n\r\n  // \r\n  saMinWidth = 'saMinWidth',\r\n\r\n  // \r\n  saNonhighlightColor = 'saNonhighlightColor',\r\n\r\n  // \r\n  saOmitOnSpecial = 'saOmitOnSpecial',\r\n\r\n  // \r\n  saOpacity = 'saOpacity',\r\n\r\n  // \r\n  saOrientation = 'saOrientation',\r\n\r\n  // \r\n  saPadding = 'saPadding',\r\n\r\n  // \r\n  saPaddingTop = 'saPaddingTop',\r\n\r\n  // \r\n  saPaddingRight = 'saPaddingRight',\r\n\r\n  // \r\n  saPaddingBottom = 'saPaddingBottom',\r\n\r\n  // \r\n  saPaddingLeft = 'saPaddingLeft',\r\n\r\n  // \r\n  saPalette = 'saPalette',\r\n\r\n  // \r\n  saRenderFoldReversed = 'saRenderFoldReversed',\r\n\r\n  // \r\n  saReversePalette = 'saReversePalette',\r\n\r\n  // \r\n  saRounding = 'saRounding',\r\n\r\n  // \r\n  saRowHorizLevels = 'saRowHorizLevels',\r\n\r\n  // \r\n  saRowHorizWidth = 'saRowHorizWidth',\r\n\r\n  // \r\n  saRowLevels = 'saRowLevels',\r\n\r\n  // \r\n  saRowVertWidth = 'saRowVertWidth',\r\n\r\n  // \r\n  saSeparator = 'saSeparator',\r\n\r\n  // \r\n  saShape = 'saShape',\r\n\r\n  // Deprecated\r\n  saShowLabels = 'saShowLabels',\r\n\r\n  // \r\n  saSize = 'saSize',\r\n\r\n  // \r\n  saSizeBar = 'saSizeBar',\r\n\r\n  // \r\n  saSmartAutoAlignment = 'saSmartAutoAlignment',\r\n\r\n  // \r\n  saSpace = 'saSpace',\r\n\r\n  // \r\n  saStrokeColor = 'saStrokeColor',\r\n\r\n  // \r\n  saStrokeSize = 'saStrokeSize',\r\n\r\n  // \r\n  saSubtitle = 'saSubtitle',\r\n\r\n  // \r\n  saTextAlign = 'saTextAlign',\r\n\r\n  // \r\n  saTextAlignDefault = 'saTextAlignDefault',\r\n\r\n  // \r\n  saTextDecoration = 'saTextDecoration',\r\n\r\n  // \r\n  saTextIndent = 'saTextIndent',\r\n\r\n  // \r\n  saTextOrientation = 'saTextOrientation',\r\n\r\n  // \r\n  saTextFormat = 'saTextFormat',\r\n\r\n  // \r\n  saTickColor = 'saTickColor',\r\n\r\n  // \r\n  saTickLength = 'saTickLength',\r\n\r\n  // Deprecated\r\n  saTickSpacing = 'saTickSpacing',\r\n\r\n  // \r\n  saTitle = 'saTitle',\r\n\r\n  // \r\n  saTotalLabel = 'saTotalLabel',\r\n\r\n  // \r\n  saVAlign = 'saVAlign',\r\n\r\n  // \r\n  saVerticalAlign = 'saVerticalAlign',\r\n\r\n  // \r\n  saVerticalAlignDefault = 'saVerticalAlignDefault',\r\n\r\n  // \r\n  saVnaxis = 'saVnaxis',\r\n\r\n  // \r\n  saVnlabel = 'saVnlabel',\r\n\r\n  // \r\n  saWarnOnSpecial = 'saWarnOnSpecial',\r\n\r\n  // \r\n  saWashout = 'saWashout',\r\n\r\n  // \r\n  saWhiskerEnd = 'saWhiskerEnd',\r\n\r\n  // \r\n  saWhiskerStrokeColor = 'saWhiskerStrokeColor',\r\n\r\n  // \r\n  saWhiskerStrokeSize = 'saWhiskerStrokeSize',\r\n\r\n  // \r\n  saWidth = 'saWidth',\r\n\r\n  // \r\n  saWidthHeader = 'saWidthHeader',\r\n\r\n  // \r\n  saWrap = 'saWrap',\r\n\r\n  // \r\n  saZoom = 'saZoom',\r\n\r\n  // Special attributes used for matching\r\n  saNone = 'saNone',\r\n\r\n  // Special attributes used for matching\r\n  saAny = 'saAny'\r\n}\r\n\r\n// lowest bit of enum value denotes two-tone styles; newly added styles should follow this pattern.\r\nexport enum BoxplotStyle {\r\n\r\n  // mask for checking if a style is two-tone\r\n  BoxplotStyleTwoTone = 'two-tone',\r\n\r\n  // \r\n  BoxplotStyleModern = 'modern',\r\n\r\n  // \r\n  BoxplotStyleGlass = 'glass',\r\n\r\n  // \r\n  BoxplotStyleClassic = 'classic',\r\n\r\n  // \r\n  BoxplotStyleClassicTwoTone = 'classic-two-tone'\r\n}\r\n\r\n// used for boxplots and prediction band whiskers\r\nexport enum WhiskerEnd {\r\n\r\n  // \r\n  WhiskerEndNone = 'none',\r\n\r\n  // \r\n  WhiskerEndSmall = 'small',\r\n\r\n  // \r\n  WhiskerEndLarge = 'large'\r\n}\r\n\r\n// \r\nexport enum StyleElement {\r\n\r\n  // \r\n  elementAxis = 'elementAxis',\r\n\r\n  // \r\n  elementCell = 'elementCell',\r\n\r\n  // \r\n  elementDatalabel = 'elementDatalabel',\r\n\r\n  // \r\n  elementDropspot = 'elementDropspot',\r\n\r\n  // \r\n  elementHeader = 'elementHeader',\r\n\r\n  // \r\n  elementFieldLabel = 'elementFieldLabel',\r\n\r\n  // \r\n  elementFieldLabelDecoration = 'elementFieldLabelDecoration',\r\n\r\n  // \r\n  elementFieldLabelSpanner = 'elementFieldLabelSpanner',\r\n\r\n  // \r\n  elementLabel = 'elementLabel',\r\n\r\n  // \r\n  elementMark = 'elementMark',\r\n\r\n  // \r\n  elementPane = 'elementPane',\r\n\r\n  // \r\n  elementTable = 'elementTable',\r\n\r\n  // \r\n  elementWorksheet = 'elementWorksheet',\r\n\r\n  // \r\n  elementBasesheet = 'elementBasesheet',\r\n\r\n  // \r\n  elementDashboard = 'elementDashboard',\r\n\r\n  // \r\n  elementStoryboard = 'elementStoryboard',\r\n\r\n  // \r\n  elementCaption = 'elementCaption',\r\n\r\n  // \r\n  elementDropline = 'elementDropline',\r\n\r\n  // \r\n  elementRefline = 'elementRefline',\r\n\r\n  // \r\n  elementRefBand = 'elementRefBand',\r\n\r\n  // \r\n  elementRefBoxplot = 'elementRefBoxplot',\r\n\r\n  // \r\n  elementGridline = 'elementGridline',\r\n\r\n  // \r\n  elementZeroline = 'elementZeroline',\r\n\r\n  // \r\n  elementTrendline = 'elementTrendline',\r\n\r\n  // \r\n  elementTableDiv = 'elementTableDiv',\r\n\r\n  // \r\n  elementHeaderDiv = 'elementHeaderDiv',\r\n\r\n  // \r\n  elementMappedImage = 'elementMappedImage',\r\n\r\n  // \r\n  elementAction = 'elementAction',\r\n\r\n  // \r\n  elementTitle = 'elementTitle',\r\n\r\n  // \r\n  elementLegend = 'elementLegend',\r\n\r\n  // \r\n  elementLegendTitle = 'elementLegendTitle',\r\n\r\n  // \r\n  elementLegendTitleText = 'elementLegendTitleText',\r\n\r\n  // \r\n  elementAxisTitle = 'elementAxisTitle',\r\n\r\n  // \r\n  elementAnnotation = 'elementAnnotation',\r\n\r\n  // \r\n  elementDashTitle = 'elementDashTitle',\r\n\r\n  // \r\n  elementDashSubtitle = 'elementDashSubtitle',\r\n\r\n  // \r\n  elementDashText = 'elementDashText',\r\n\r\n  // \r\n  elementDashZone = 'elementDashZone',\r\n\r\n  // \r\n  elementDashContainer = 'elementDashContainer',\r\n\r\n  // \r\n  elementScrollbar = 'elementScrollbar',\r\n\r\n  // Static on/off map layers\r\n  elementMapLayer = 'elementMapLayer',\r\n\r\n  // Contains washout\r\n  elementMap = 'elementMap',\r\n\r\n  // Initially for UrbanMapping/Claritas data\r\n  elementMapDataLayer = 'elementMapDataLayer',\r\n\r\n  // \r\n  elementQuickFilter = 'elementQuickFilter',\r\n\r\n  // \r\n  elementQuickFilterTitle = 'elementQuickFilterTitle',\r\n\r\n  // \r\n  elementParameterCtrl = 'elementParameterCtrl',\r\n\r\n  // \r\n  elementParameterCtrlTitle = 'elementParameterCtrlTitle',\r\n\r\n  // \r\n  elementPageCardTitle = 'elementPageCardTitle',\r\n\r\n  // \r\n  elementStoryDescription = 'elementStoryDescription',\r\n\r\n  // \r\n  elementStoryPointCaption = 'elementStoryPointCaption',\r\n\r\n  // \r\n  elementStoryTitle = 'elementStoryTitle',\r\n\r\n  // \r\n  elementTooltip = 'elementTooltip',\r\n\r\n  // \r\n  elementAll = 'elementAll',\r\n\r\n  // \r\n  elementPageCardBody = 'elementPageCardBody',\r\n\r\n  // \r\n  elementDataHighlighter = 'elementDataHighlighter',\r\n\r\n  // \r\n  elementDataHighlighterTitle = 'elementDataHighlighterTitle',\r\n\r\n  // Special elements used for matching and organization\r\n  elementNone = 'elementNone',\r\n\r\n  // Special elements used for matching and organization\r\n  elementAny = 'elementAny',\r\n\r\n  // Special elements used for matching and organization\r\n  elementRoot = 'elementRoot'\r\n}\r\n\r\n// Do not mess with these values. They are sometimes used as array indexes/bounds\r\nexport enum StyleDataClass {\r\n\r\n  // \r\n  dcNormal = 'dcNormal',\r\n\r\n  // \r\n  dcTotal = 'dcTotal',\r\n\r\n  // \r\n  dcSubtotal = 'dcSubtotal',\r\n\r\n  // \r\n  dcCOUNT = 'dcCOUNT'\r\n}\r\n\r\n// \r\nexport enum StyleFieldScope {\r\n\r\n  // \r\n  fsNone = 'fsNone',\r\n\r\n  // \r\n  fsRows = 'fsRows',\r\n\r\n  // \r\n  fsCols = 'fsCols'\r\n}\r\n\r\n// \r\nexport enum StyleSwatch {\r\n\r\n  // \r\n  ssUnspecified = 'ssUnspecified',\r\n\r\n  // \r\n  ssLight = 'ssLight',\r\n\r\n  // \r\n  ssDark = 'ssDark'\r\n}\r\n\r\n// \r\nexport enum TableauFontStyle {\r\n\r\n  // \r\n  NormalStyle = 'font-style-normal',\r\n\r\n  // \r\n  Italic = 'font-style-italic'\r\n}\r\n\r\n// Unsupported for Betsy\r\nexport enum TextDecoration {\r\n\r\n  // \r\n  NoDecoration = 'text-decoration-none',\r\n\r\n  // \r\n  Underline = 'text-decoration-underline',\r\n\r\n  // not yet supported\r\n  Overline = 'text-decoration-overline',\r\n\r\n  // \r\n  Strikethrough = 'text-decoration-strikethrough'\r\n}\r\n\r\n// \r\nexport enum FontWeight {\r\n\r\n  // \r\n  NormalWeight = 'font-weight-normal',\r\n\r\n  // \r\n  Bold = 'font-weight-bold'\r\n}\r\n\r\n// \r\nexport enum TextOrient {\r\n\r\n  // \r\n  TO_Auto = 'text-orient-auto',\r\n\r\n  // \r\n  TO_Horz = 'text-orient-horizontal',\r\n\r\n  // \r\n  TO_VertUp = 'text-orient-vertical-up',\r\n\r\n  // \r\n  TO_VertDown = 'text-orient-vertical-down'\r\n}\r\n\r\n// \r\nexport enum TextAlign {\r\n\r\n  // \r\n  TA_Start = 'text-align-start',\r\n\r\n  // \r\n  TA_Center = 'text-align-center',\r\n\r\n  // \r\n  TA_End = 'text-align-end'\r\n}\r\n\r\n// \r\nexport enum TextWrapMode {\r\n\r\n  // \r\n  TextWrapOff = 'text-wrap-off',\r\n\r\n  // \r\n  TextWrapTruncate = 'text-wrap-truncate',\r\n\r\n  // \r\n  TextWrapOn = 'text-wrap-on',\r\n\r\n  // \r\n  TextWrapAuto = 'text-wrap-auto'\r\n}\r\n\r\n// \r\nexport enum TextWholeLineMode {\r\n\r\n  // \r\n  TextWholeLineOff = 'text-whole-line-off',\r\n\r\n  // \r\n  TextWholeLineOn = 'text-whole-line-on',\r\n\r\n  // \r\n  TextWholeLineAuto = 'text-whole-line-auto'\r\n}\r\n\r\n// \r\nexport enum TextBreakMode {\r\n\r\n  // \r\n  TextBreakWhitespaceOnly = 'text-break-ws-only',\r\n\r\n  // \r\n  TextBreakAuto = 'text-break-auto'\r\n}\r\n\r\n// type of aggregation\r\nexport enum AggType {\r\n\r\n  // \r\n  AGG_SUM = 'sum',\r\n\r\n  // \r\n  AGG_AVG = 'average',\r\n\r\n  // \r\n  AGG_MIN = 'min',\r\n\r\n  // \r\n  AGG_MAX = 'max',\r\n\r\n  // \r\n  AGG_STDEV = 'std-dev',\r\n\r\n  // \r\n  AGG_STDEVP = 'std-dev-p',\r\n\r\n  // \r\n  AGG_VAR = 'var',\r\n\r\n  // \r\n  AGG_VARP = 'var-p',\r\n\r\n  // \r\n  AGG_COUNT = 'count',\r\n\r\n  // \r\n  AGG_COUNTD = 'count-d',\r\n\r\n  // \r\n  AGG_MEDIAN = 'median',\r\n\r\n  // \r\n  AGG_ATTR = 'attr',\r\n\r\n  // \r\n  AGG_NONE = 'none',\r\n\r\n  // \r\n  AGG_PERCENTILE = 'percentile',\r\n\r\n  // \r\n  AGG_YEAR = 'year',\r\n\r\n  // \r\n  AGG_QTR = 'qtr',\r\n\r\n  // \r\n  AGG_MONTH = 'month',\r\n\r\n  // \r\n  AGG_DAY = 'day',\r\n\r\n  // \r\n  AGG_HOUR = 'hour',\r\n\r\n  // \r\n  AGG_MINUTE = 'minute',\r\n\r\n  // \r\n  AGG_SECOND = 'second',\r\n\r\n  // \r\n  AGG_WEEK = 'week',\r\n\r\n  // \r\n  AGG_WEEKDAY = 'weekday',\r\n\r\n  // \r\n  AGG_MONTHYEAR = 'month-year',\r\n\r\n  // \r\n  AGG_MDY = 'mdy',\r\n\r\n  // \r\n  AGG_END = 'end',\r\n\r\n  // \r\n  TRUNC_YEAR = 'trunc-year',\r\n\r\n  // \r\n  TRUNC_QTR = 'trunc-qtr',\r\n\r\n  // \r\n  TRUNC_MONTH = 'trunc-month',\r\n\r\n  // \r\n  TRUNC_WEEK = 'trunc-week',\r\n\r\n  // \r\n  TRUNC_DAY = 'trunc-day',\r\n\r\n  // \r\n  TRUNC_HOUR = 'trunc-hour',\r\n\r\n  // \r\n  TRUNC_MINUTE = 'trunc-minute',\r\n\r\n  // \r\n  TRUNC_SECOND = 'trunc-second',\r\n\r\n  // \r\n  AGG_QUART1 = 'quart1',\r\n\r\n  // \r\n  AGG_QUART3 = 'quart3',\r\n\r\n  // \r\n  AGG_SKEWNESS = 'skewness',\r\n\r\n  // \r\n  AGG_KURTOSIS = 'kurtosis',\r\n\r\n  // \r\n  AGG_INOUT = 'in-out',\r\n\r\n  // \r\n  AGG_SUM_XSQR = 'sum-xsqr',\r\n\r\n  // \r\n  AGG_USER = 'user',\r\n\r\n  // \r\n  AGG_COLLECT = 'collect',\r\n\r\n  // \r\n  AGG_COVAR = 'covar',\r\n\r\n  // \r\n  AGG_COVARP = 'covarp',\r\n\r\n  // \r\n  AGG_CORR = 'corr'\r\n}\r\n\r\n// DataValueFormatter::DataTypeEncodings has hardcoded values corresponding to following enum members. So any changes here should be done there too\r\nexport enum DataType {\r\n\r\n  // \r\n  DT_INTEGER = 'integer',\r\n\r\n  // \r\n  DT_REAL = 'real',\r\n\r\n  // \r\n  DT_STRING = 'cstring',\r\n\r\n  // \r\n  DT_DATETIME = 'datetime',\r\n\r\n  // \r\n  DT_BOOLEAN = 'boolean',\r\n\r\n  // \r\n  DT_DATE = 'date',\r\n\r\n  // \r\n  DT_TUPLE = 'tuple',\r\n\r\n  // \r\n  DT_SPATIAL = 'spatial',\r\n\r\n  // \r\n  DT_UNKNOWN = 'unknown',\r\n\r\n  // \r\n  DT_BINARY = 'binary',\r\n\r\n  // \r\n  DT_TIME = 'time'\r\n}\r\n\r\n// \r\nexport enum DatePeriodType {\r\n\r\n  // \r\n  PeriodYear = 'year',\r\n\r\n  // \r\n  PeriodQuarter = 'quarter',\r\n\r\n  // \r\n  PeriodMonth = 'month',\r\n\r\n  // \r\n  PeriodWeek = 'week',\r\n\r\n  // \r\n  PeriodDay = 'day',\r\n\r\n  // \r\n  PeriodHour = 'hour',\r\n\r\n  // \r\n  PeriodMinute = 'minute',\r\n\r\n  // \r\n  PeriodSecond = 'second'\r\n}\r\n\r\n// Format prepended to format strings to specify type\r\nexport enum FormatCode {\r\n\r\n  // \r\n  AutoFormat = 'auto-format',\r\n\r\n  // \r\n  SystemLongDate = 'system-long-date',\r\n\r\n  // \r\n  SystemShortDate = 'system-short-date',\r\n\r\n  // \r\n  SystemNumber = 'system-number',\r\n\r\n  // \r\n  SystemCurrency = 'system-currency',\r\n\r\n  // \r\n  SystemTime = 'system-time',\r\n\r\n  // \r\n  Custom = 'custom',\r\n\r\n  // \r\n  CustomICU = 'custom-icu',\r\n\r\n  // \r\n  CustomNumber = 'custom-number',\r\n\r\n  // \r\n  CustomCurrency = 'custom-currency',\r\n\r\n  // \r\n  CustomScientific = 'custom-scientific',\r\n\r\n  // \r\n  CustomPercentage = 'custom-percentage'\r\n}\r\n\r\n// Units specified in a format string\r\nexport enum UnitsFormatEnum {\r\n\r\n  // \r\n  UnitsFmtNone = 'units-none',\r\n\r\n  // \r\n  UnitsFmtThousands = 'units-thousands',\r\n\r\n  // \r\n  UnitsFmtMillions = 'units-millions',\r\n\r\n  // \r\n  UnitsFmtBillionsEnglish = 'units-billions-english',\r\n\r\n  // \r\n  UnitsFmtBillionsStandard = 'units-billions-standard'\r\n}\r\n\r\n// \r\nexport enum ForecastColumnType {\r\n\r\n  // \r\n  FORECAST_NONE = 'none',\r\n\r\n  // \r\n  FORECAST_VALUE = 'value',\r\n\r\n  // \r\n  FORECAST_INDICATOR = 'indicator',\r\n\r\n  // \r\n  FORECAST_PRECISION = 'precision',\r\n\r\n  // \r\n  FORECAST_QUALITY = 'quality',\r\n\r\n  // \r\n  FORECAST_FIT_TREND = 'fit_trend',\r\n\r\n  // \r\n  FORECAST_PRECISION_PERCENT = 'precision_percent',\r\n\r\n  // \r\n  FORECAST_PREDICTION_INTERVAL_UPPER = 'prediction_upper',\r\n\r\n  // \r\n  FORECAST_PREDICTION_INTERVAL_LOWER = 'prediction_lower'\r\n}\r\n\r\n// \r\nexport enum MarkMarkersMode {\r\n\r\n  // \r\n  MMM_Auto = 'mmm-auto',\r\n\r\n  // \r\n  MMM_All = 'mmm_all',\r\n\r\n  // \r\n  MMM_None = 'mmm_none',\r\n\r\n  // \r\n  MMM_Default = 'mmm_default'\r\n}\r\n\r\n// \r\nexport enum PercentMode {\r\n\r\n  // \r\n  PERCENT_CELL_IN_PANE = 'cell-in-pane',\r\n\r\n  // \r\n  PERCENT_ROW_IN_PANE = 'row-in-pane',\r\n\r\n  // \r\n  PERCENT_COLUMN_IN_PANE = 'column-in-pane',\r\n\r\n  // \r\n  PERCENT_PANE = 'pane',\r\n\r\n  // \r\n  PERCENT_ROW = 'row',\r\n\r\n  // \r\n  PERCENT_COLUMN = 'column',\r\n\r\n  // \r\n  PERCENT_TABLE = 'table'\r\n}\r\n\r\n// \r\nexport enum SpecialValuesMode {\r\n\r\n  // \r\n  SPECIAL_VALUES_HIDE_AND_WARN = 'hide-and-warn',\r\n\r\n  // \r\n  SPECIAL_VALUES_HIDE = 'hide',\r\n\r\n  // \r\n  SPECIAL_VALUES_HIDE_BREAK_LINES = 'hide-break-lines',\r\n\r\n  // \r\n  SPECIAL_VALUES_SHOW = 'show'\r\n}\r\n\r\n// \r\nexport enum LayoutType {\r\n\r\n  // \r\n  LAYOUT_CARTESIAN = 'cartesian',\r\n\r\n  // \r\n  LAYOUT_DEFAULT = 'default'\r\n}\r\n\r\n// \r\nexport enum ShelfType {\r\n\r\n  // \r\n  ST_NONE = 'none-shelf',\r\n\r\n  // \r\n  ST_COLUMNS_SHELF = 'columns-shelf',\r\n\r\n  // \r\n  ST_ROWS_SHELF = 'rows-shelf',\r\n\r\n  // \r\n  ST_PAGES_SHELF = 'pages-shelf',\r\n\r\n  // \r\n  ST_FILTER_SHELF = 'filter-shelf',\r\n\r\n  // \r\n  ST_IMAGE_SHELF = 'image-shelf',\r\n\r\n  // \r\n  ST_MEASURES_SHELF = 'measures-shelf',\r\n\r\n  // \r\n  ST_SHOWME_SHELF = 'show-me-shelf',\r\n\r\n  // \r\n  ST_ENCODING_SHELF = 'encoding-shelf',\r\n\r\n  // \r\n  ST_CLUSTER_SHELF = 'cluster-shelf',\r\n\r\n  // \r\n  ST_GEOMETRY_SHELF = 'geometry-shelf',\r\n\r\n  // \r\n  ST_END = 'end-shelf',\r\n\r\n  // \r\n  ST_FINAL = 'final-shelf'\r\n}\r\n\r\n// \r\nexport enum RestrictType {\r\n\r\n  // \r\n  RT_INTERSECT = 'rt-intersection',\r\n\r\n  // \r\n  RT_UNION = 'rt-union'\r\n}\r\n\r\n// \r\nexport enum TooltipMode {\r\n\r\n  // \r\n  TM_NONE = 'none',\r\n\r\n  // \r\n  TM_STICKY = 'sticky',\r\n\r\n  // \r\n  TM_SMOOTH = 'smooth',\r\n}\r\n\r\n// \r\nexport enum ColumnGroups {\r\n\r\n  // 0x01\r\n  COLS_IN_OUTPUT = 'cols-in-output',\r\n\r\n  // 0x02\r\n  COLS_IN_FILTER_SHELF = 'cols-in-filter-shelf',\r\n\r\n  // 0x04\r\n  COLS_REF_BY_FILTERS = 'cols-ref-by-filters',\r\n\r\n  // 0x08\r\n  COLS_REF_BY_OMEASURES = 'cols-ref-by-omeasures',\r\n\r\n  // 0x10\r\n  COLS_REF_BY_JOIN_LOD = 'cols-ref-by-join-lod',\r\n\r\n  // 0x20\r\n  COLS_HIDDEN = 'cols-hidden',\r\n\r\n  // 0x40\r\n  COLS_REF_BY_SORTS = 'cols-ref-by-sorts',\r\n\r\n  // \r\n  COLS_REF_BY_FILTERS_OR_SORTS = 'cols-ref-by-filters-or-sorts',\r\n\r\n  // \r\n  COLS_ON_SHELVES = 'cols-on-shelves',\r\n\r\n  // \r\n  COLS_ALL = 'cols-all'\r\n}\r\n\r\n// \r\nexport enum ButtonsOption {\r\n\r\n  // \r\n  BO_HIDE = 'buttons-hide'\r\n}\r\n\r\n// \r\nexport enum SelectionRelaxationOption {\r\n\r\n  // \r\n  SRO_ALLOW = 'selection-relaxation-allow',\r\n\r\n  // \r\n  SRO_DISALLOW = 'selection-relaxation-disallow',\r\n}\r\n\r\n// \r\nexport enum EncodingType {\r\n\r\n  // a text encoding\r\n  ET_TEXT = 'text-encoding',\r\n\r\n  // a color encoding\r\n  ET_COLOR = 'color-encoding',\r\n\r\n  // a size encoding\r\n  ET_SIZE = 'size-encoding',\r\n\r\n  // a shape encoding\r\n  ET_SHAPE = 'shape-encoding',\r\n\r\n  // an image encoding\r\n  ET_IMAGE = 'image-encoding',\r\n\r\n  // a sort (path) encoding (currently only for line or polygon charts)\r\n  ET_SORT = 'sort-encoding',\r\n\r\n  // a wedge size (angle) encoding (currently only for pie charts)\r\n  ET_WEDGESIZE = 'wedge-size-encoding',\r\n\r\n  // a geometry encoding\r\n  ET_GEOMETRY = 'geometry-encoding',\r\n\r\n  // a level of detail encoding\r\n  ET_LOD = 'level-of-detail-encoding',\r\n\r\n  // encoding used for the data highlighter/legend mechanism\r\n  ET_HIGHLIGHT = 'highlight-encoding',\r\n\r\n  // a tooltip encoding\r\n  ET_TOOLTIP = 'tooltip-encoding',\r\n\r\n  // a temporary label placed above marks for the table calc dialog\r\n  ET_RUNNINGORDER = 'runningorder-encoding',\r\n\r\n  // the number of encodings, this is invalid input for an encoding presentation model\r\n  NUM_ENCODINGS = 'num-encodings',\r\n\r\n  // an invalid encoding\r\n  ET_INVALID = 'invalid-encoding'\r\n}\r\n\r\n// Enumeration of valid horizontal alignments.\r\nexport enum LabelHAlignment {\r\n\r\n  // \r\n  LHA_Left = 'h-align-left',\r\n\r\n  // \r\n  LHA_Center = 'h-align-center',\r\n\r\n  // \r\n  LHA_Right = 'h-align-right',\r\n\r\n  // \r\n  LHA_Automatic = 'h-align-auto'\r\n}\r\n\r\n// Enumeration of valid vertical alignments.\r\nexport enum LabelVAlignment {\r\n\r\n  // \r\n  LVA_Bottom = 'v-align-bottom',\r\n\r\n  // \r\n  LVA_Center = 'v-align-center',\r\n\r\n  // \r\n  LVA_Top = 'v-align-top',\r\n\r\n  // \r\n  LVA_Automatic = 'v-align-auto'\r\n}\r\n\r\n// Enumeration of valid label positions.\r\nexport enum LabelPosition {\r\n\r\n  // Position each text run relative to the center of the original bbox.  Use the original bbox as the height and width of the text mark.  Used for non-stacked OO text marks.\r\n  CenterInOriginalBbox = 'label-position-center-in-original-box',\r\n\r\n  // Position each text run relative to the bottom left corner of the measured bbox. Use the measured bbox as the width and height of the label. Used for labels\r\n  OriginAtLowerLeft = 'label-position-origin-at-lower-left',\r\n\r\n  // Position each text run relative to the center of the measured bbox. Use the measured bbox as the width and height of the text mark. Used for most text marks.\r\n  OriginAtCenter = 'label-position-origin-at-center'\r\n}\r\n\r\n// Enumeration of ways to use color.  Values can be or'ed together to make a mask for allowed options\r\nexport enum ColorMode {\r\n\r\n  // Color user specified\r\n  CLRM_User = 'clrm-user',\r\n\r\n  // Color selected automatically\r\n  CLRM_Auto = 'clrm-auto',\r\n\r\n  // Color matches mark color\r\n  CLRM_Match = 'clrm-match',\r\n\r\n  // No color (transparent or not drawn)\r\n  CLRM_None = 'clrm-none'\r\n}\r\n\r\n// \r\nexport enum MarkLabelsMode {\r\n\r\n  // \r\n  MLM_All = 'mlm-all',\r\n\r\n  // \r\n  MLM_Selection = 'mlm-selection',\r\n\r\n  // \r\n  MLM_Highlight = 'mlm-highlight',\r\n\r\n  // \r\n  MLM_LineEnds = 'mlm-line-ends',\r\n\r\n  // min/max setting\r\n  MLM_Range = 'mlm-range',\r\n\r\n  // most recent (only relevant when date field is in play)\r\n  MLM_MostRecent = 'mlm-most-recent',\r\n\r\n  // ...this is \" virtual \" (runtime only, not saved, not shown as a user setting\r\n  MLM_MultipleValues = 'mlm-multiple-values',\r\n\r\n  // \r\n  MLM_Default = 'mlm-default'\r\n}\r\n\r\n// \r\nexport enum MarkLabelsScope {\r\n\r\n  // \r\n  MLS_Table = 'mls-table',\r\n\r\n  // \r\n  MLS_Pane = 'mls-pane',\r\n\r\n  // \r\n  MLS_Cell = 'mls-cell',\r\n\r\n  // \r\n  MLS_MultiMark = 'mls-multimark',\r\n\r\n  // ...this is \" virtual \" (runtime only, not saved, not shown as a user setting)\r\n  MLS_MultipleValues = 'mls-multiple-values',\r\n\r\n  // \r\n  MLS_Default = 'mls-default'\r\n}\r\n\r\n// \r\nexport enum MarkLabelsVisibility {\r\n\r\n  // \r\n  MLV_Hidden = 'mlv-hidden',\r\n\r\n  // \r\n  MLV_Visible = 'mlv-visible',\r\n\r\n  // \r\n  MLV_UseCurrent = 'mlv-use-current'\r\n}\r\n\r\n// \r\nexport enum StackingMode {\r\n\r\n  // \r\n  StackingOff = 'off',\r\n\r\n  // \r\n  StackingOn = 'on',\r\n\r\n  // \r\n  StackingAuto = 'auto'\r\n}\r\n\r\n// \r\nexport enum MarkAlignment {\r\n\r\n  // \r\n  MarkAlignmentLeft = 'mark-alignment-left',\r\n\r\n  // \r\n  MarkAlignmentRight = 'mark-alignment-right',\r\n\r\n  // \r\n  MarkAlignmentCenter = 'mark-alignment-center'\r\n}\r\n\r\n// \r\nexport enum PaneLabelComposition {\r\n\r\n  // \r\n  PLC_None = 'pane-label-composition-none',\r\n\r\n  // \r\n  PLC_Mixed = 'pane-label-composition-mixed',\r\n\r\n  // \r\n  PLC_All = 'pane-label-composition-all'\r\n}\r\n\r\n// The user-specified mark type on the Marks Card\r\nexport enum PrimitiveType {\r\n\r\n  // \r\n  PT_AUTOMATIC = 'automatic',\r\n\r\n  // \r\n  PT_TEXT = 'text',\r\n\r\n  // \r\n  PT_IMAGE = 'image',\r\n\r\n  // \r\n  PT_SHAPE = 'shape',\r\n\r\n  // \r\n  PT_RECTANGLE = 'rectangle',\r\n\r\n  // \r\n  PT_BAR = 'bar',\r\n\r\n  // \r\n  PT_GANTT = 'gantt',\r\n\r\n  // \r\n  PT_SQUARE = 'square',\r\n\r\n  // \r\n  PT_CIRCLE = 'circle',\r\n\r\n  // \r\n  PT_POLYLINE = 'polyline',\r\n\r\n  // line chart\r\n  PT_LINE = 'line',\r\n\r\n  // \r\n  PT_POLYGON = 'polygon',\r\n\r\n  // area chart\r\n  PT_AREA = 'area',\r\n\r\n  // \r\n  PT_PIE = 'pie',\r\n\r\n  // \r\n  PT_MULTIPOLYGON = 'multipolygon',\r\n\r\n  // Not an actual primitive type. This is just used to flag the UI that multiple types are in play.\r\n  PT_MULTIPLE = 'multiple',\r\n\r\n  // used for looping over all values\r\n  NUM_PRIMITIVES = 'count',\r\n\r\n  // used to flag an unset or invalid state\r\n  PT_INVALID = 'invalid'\r\n}\r\n\r\n// Defines the way a given primitive behaves on a viz - for instance, a PT_CIRCLE is treated as a point, while a PT_POLYGON would be treated as an area.\r\nexport enum MarkType {\r\n\r\n  // \r\n  MT_POINT = 'point',\r\n\r\n  // \r\n  MT_LINE = 'line',\r\n\r\n  // \r\n  MT_AREA = 'area',\r\n\r\n  // \r\n  MT_INVALID = 'invalid'\r\n}\r\n\r\n// PaneAxis is used to describe which axis of a pane is the independent axis.\r\nexport enum PaneAxis {\r\n\r\n  // The independent axis is inferred from other properties of the pane.\r\n  AXIS_AUTO = 'auto',\r\n\r\n  // \r\n  AXIS_X = 'x',\r\n\r\n  // \r\n  AXIS_Y = 'y'\r\n}\r\n\r\n// \r\nexport enum Rounding {\r\n\r\n  // \r\n  Rounding_None = 'none',\r\n\r\n  // \r\n  Rounding_Small = 'small',\r\n\r\n  // \r\n  Rounding_Medium = 'medium',\r\n\r\n  // \r\n  Rounding_Large = 'large'\r\n}\r\n\r\n// \r\nexport enum LineEnd {\r\n\r\n  // \r\n  LineEnd_None = 'none',\r\n\r\n  // \r\n  LineEnd_Arrow = 'arrow',\r\n\r\n  // \r\n  LineEnd_OpenArrow = 'open-arrow',\r\n\r\n  // \r\n  LineEnd_Dot = 'dot'\r\n}\r\n\r\n// \r\nexport enum LineEndSize {\r\n\r\n  // \r\n  LineEndSize_Smallest = 'smallest',\r\n\r\n  // \r\n  LineEndSize_Smaller = 'smaller',\r\n\r\n  // \r\n  LineEndSize_Small = 'small',\r\n\r\n  // \r\n  LineEndSize_Medium = 'medium',\r\n\r\n  // \r\n  LineEndSize_Large = 'large',\r\n\r\n  // \r\n  LineEndSize_Larger = 'larger',\r\n\r\n  // \r\n  LineEndSize_Largest = 'largest'\r\n}\r\n\r\n// \r\nexport enum BodyType {\r\n\r\n  // \r\n  BodyType_None = 'none',\r\n\r\n  // \r\n  BodyType_Box = 'box',\r\n\r\n  // \r\n  BodyType_Edge = 'edge'\r\n}\r\n\r\n// \r\nexport enum StyleTheme {\r\n\r\n  // \r\n  themeClassic = 'classic',\r\n\r\n  // \r\n  themeModern = 'modern',\r\n\r\n  // \r\n  themeClean = 'clean',\r\n\r\n  // \r\n  themeSmooth = 'smooth',\r\n\r\n  // \r\n  themeCustom = 'custom'\r\n}\r\n\r\n// \r\nexport enum AxisFoldState {\r\n\r\n  // \r\n  afNone = 'none',\r\n\r\n  // \r\n  afFolded = 'folded',\r\n\r\n  // \r\n  afSynchronized = 'synchronized'\r\n}\r\n\r\n// \r\nexport enum LinePattern {\r\n\r\n  // \r\n  LinePatternNone = 'none',\r\n\r\n  // \r\n  LinePatternSolid = 'solid',\r\n\r\n  // \r\n  LinePatternDashed = 'dashed',\r\n\r\n  // \r\n  LinePatternDotted = 'dotted'\r\n}\r\n\r\n// \r\nexport enum LineVisibility {\r\n\r\n  // \r\n  LineVisibilityAuto = 'automatic',\r\n\r\n  // \r\n  LineVisibilityOn = 'on',\r\n\r\n  // \r\n  LineVisibilityOff = 'off'\r\n}\r\n\r\n// \r\nexport enum StylesLinePattern {\r\n\r\n  // \r\n  StylesLinePatternSolid = 'solid',\r\n\r\n  // \r\n  StylesLinePatternDashed = 'dashed',\r\n\r\n  // \r\n  StylesLinePatternDotted = 'dotted'\r\n}\r\n\r\n// \r\nexport enum LineCap {\r\n\r\n  // \r\n  LineCapFlat = 'flat',\r\n\r\n  // \r\n  LineCapSquare = 'square',\r\n\r\n  // \r\n  LineCapRound = 'round',\r\n\r\n  // \r\n  LineCapTriangle = 'triangle'\r\n}\r\n\r\n// \r\nexport enum LineJoin {\r\n\r\n  // \r\n  BevelJoin = 'bevel',\r\n\r\n  // \r\n  MiterJoin = 'miter',\r\n\r\n  // \r\n  RoundJoin = 'round'\r\n}\r\n\r\n// \r\nexport enum LineAlignment {\r\n\r\n  // \r\n  AlignmentCenter = 'center',\r\n\r\n  // \r\n  AlignmentInset = 'inset'\r\n}\r\n\r\n// \r\nexport enum FillMode {\r\n\r\n  // \r\n  FillEvenOdd = 'even-odd',\r\n\r\n  // \r\n  FillWinding = 'winding'\r\n}\r\n\r\n// \r\nexport enum BorderStyle {\r\n\r\n  // none\r\n  BorderStyleNone = 'bs-none',\r\n\r\n  // hidden\r\n  BorderStyleHidden = 'bs-hidden',\r\n\r\n  // dotted\r\n  BorderStyleDotted = 'bs-dotted',\r\n\r\n  // dashed\r\n  BorderStyleDashed = 'bs-dashed',\r\n\r\n  // solid\r\n  BorderStyleSolid = 'bs-solid',\r\n\r\n  // double\r\n  BorderStyleDouble = 'bs-double',\r\n\r\n  // groove\r\n  BorderStyleGroove = 'bs-groove',\r\n\r\n  // ridge\r\n  BorderStyleRidge = 'bs-ridge',\r\n\r\n  // inset\r\n  BorderStyleInset = 'bs-inset',\r\n\r\n  // outset\r\n  BorderStyleOutset = 'bs-outset',\r\n\r\n  // invalid\r\n  BorderStyleInvalid = 'bs-invalid'\r\n}\r\n\r\n// \r\nexport enum ColorPaletteType {\r\n\r\n  // \r\n  ColorPaletteRegular = 'color-palette-regular',\r\n\r\n  // \r\n  ColorPaletteOrderedDiverging = 'palette-ordered-diverging',\r\n\r\n  // \r\n  ColorPaletteOrderedLinear = 'palette-ordered-linear'\r\n}\r\n\r\n// \r\nexport enum PaletteFlags {\r\n\r\n  // \r\n  PaletteFlagNone = 'palette-flag-none',\r\n\r\n  // \r\n  PaletteFlagCustom = 'palette-flag-custom',\r\n\r\n  // \r\n  PaletteFlagNotQuantitative = 'palette-flag-not-quantitative',\r\n\r\n  // \r\n  PaletteFlagNotCategorical = 'palette-flag-not-categorical',\r\n\r\n  // \r\n  PaletteFlagNotReferenceBand = 'palette-flag-not-reference-band',\r\n\r\n  // \r\n  PaletteFlagNotBoxplot = 'palette-flag-not-boxplot',\r\n\r\n  // \r\n  PaletteFlagNotFilledMapLight = 'palette-flag-not-filled-map-light',\r\n\r\n  // \r\n  PaletteFlagNotFilledMapDark = 'palette-flag-not-filled-map-dark',\r\n\r\n  // \r\n  PaletteFlagLegacy = 'palette-flag-legacy'\r\n}\r\n\r\n// \r\nexport enum DefaultPaletteType {\r\n\r\n  // \r\n  SmallNominal = 'palette-default-small-nominal',\r\n\r\n  // \r\n  LargeNominal = 'palette-default-large-nominal',\r\n\r\n  // \r\n  Ordinal = 'palette-default-ordinal',\r\n\r\n  // \r\n  QuantitativePositive = 'palette-default-quant-pos',\r\n\r\n  // \r\n  QuantitativeNegative = 'palette-default-quant-neg',\r\n\r\n  // \r\n  QuantitativeDiverging = 'palette-default-quant-div',\r\n\r\n  // \r\n  QuantitativePositiveLight = 'palette-default-quant-pos-light',\r\n\r\n  // \r\n  QuantitativeNegativeLight = 'palette-default-quant-neg-light',\r\n\r\n  // \r\n  QuantitativeDivergingLight = 'palette-default-quant-div-light',\r\n\r\n  // \r\n  QuantitativePositiveArea = 'palette-default-quant-pos-area',\r\n\r\n  // \r\n  QuantitativeNegativeArea = 'palette-default-quant-neg-area',\r\n\r\n  // \r\n  QuantitativeDivergingArea = 'palette-default-quant-div-area'\r\n}\r\n\r\n// \r\nexport enum ShowBounds {\r\n\r\n  // \r\n  Both = 'show-both',\r\n\r\n  // \r\n  Upper = 'show-upper',\r\n\r\n  // \r\n  Lower = 'show-lower'\r\n}\r\n\r\n// Sample vs. population standard deviation\r\nexport enum StDevType {\r\n\r\n  // \r\n  Sample = 'stdev-sample',\r\n\r\n  // \r\n  Population = 'stdev-population'\r\n}\r\n\r\n// \r\nexport enum ReferenceLineFormulaGroup {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  Line = 'line',\r\n\r\n  // \r\n  Band = 'band',\r\n\r\n  // \r\n  Distribution = 'distribution',\r\n\r\n  // \r\n  Boxplot = 'boxplot'\r\n}\r\n\r\n// \r\nexport enum ReferenceLineScopeType {\r\n\r\n  // \r\n  PerCell = 'per-cell',\r\n\r\n  // \r\n  PerPane = 'per-pane',\r\n\r\n  // \r\n  PerTable = 'per-table',\r\n}\r\n\r\n// how should the line be labeled\r\nexport enum ReferenceLineLabelType {\r\n\r\n  // no label\r\n  None = 'none',\r\n\r\n  // an automatically generated label\r\n  Automatic = 'automatic',\r\n\r\n  // \r\n  Value = 'value',\r\n\r\n  // \r\n  Computation = 'computation',\r\n\r\n  // a user defined label\r\n  Custom = 'custom',\r\n}\r\n\r\n// how should the line be computed\r\nexport enum ReferenceLineFormulaType {\r\n\r\n  // a user specified constant value\r\n  Constant = 'constant',\r\n\r\n  // \r\n  Total = 'total',\r\n\r\n  // total of all values at the given scope <- is this correct? looks like comment from FormulaTotal\r\n  Sum = 'sum',\r\n\r\n  // minimum value in the scope\r\n  Min = 'min',\r\n\r\n  // maximum value in the scope\r\n  Max = 'max',\r\n\r\n  // average value in the scope\r\n  Average = 'average',\r\n\r\n  // median value in the scope\r\n  Median = 'median',\r\n\r\n  // the n quantiles values in the scope\r\n  Quantiles = 'quantiles',\r\n\r\n  // a given percentile in the scope\r\n  Percentile = 'percentile',\r\n\r\n  // mean +- standard deviation\r\n  StandardDeviation = 'standard-deviation',\r\n\r\n  // a given confidence interval around the mean\r\n  ConfidenceInterval = 'confidence-interval',\r\n\r\n  // \r\n  MedianConfidenceInterval = 'median-confidence-interval'\r\n}\r\n\r\n// Line or confidence interval or both\r\nexport enum ReferenceLineConfidenceIntervalState {\r\n\r\n  // display line only\r\n  LineOnly = 'line-only',\r\n\r\n  // display the line and a confidence interval\r\n  LineAndConfidenceInterval = 'line-and-interval',\r\n\r\n  // display confidence interval only\r\n  ConfidenceIntervalOnly = 'interval-only'\r\n}\r\n\r\n// type of distribution. i.e. Percentage, Percentile, Quantile, and Standard Deviation\r\nexport enum ReferenceLineDistributionType {\r\n\r\n  // distribution type percentage\r\n  Percentages = 'percentages',\r\n\r\n  // distribution type percentile\r\n  Percentiles = 'percentiles',\r\n\r\n  // distribution type quantile\r\n  Quantiles = 'quantiles',\r\n\r\n  // distribution type standard deviation\r\n  StandardDeviation = 'standard-deviation'\r\n}\r\n\r\n// the kind of LOD calc to use for a given reference line\r\nexport enum ReferenceLineLODCalcType {\r\n\r\n  // Create a formula using a FIXED-like level-of-detail calculation, to which sheet filters apply, that will go onto a specific sheet\r\n  MeasureFormula = 'measure-formula',\r\n\r\n  // Create a boolean formula that can be used as a filter\r\n  BooleanFilter = 'boolean-filter'\r\n}\r\n\r\n// \r\nexport enum BoxplotWhiskerType {\r\n\r\n  // \r\n  Standard = 'standard',\r\n\r\n  // \r\n  Minmax = 'minmax'\r\n}\r\n\r\n// categories of connection types displayed by the connection UI\r\nexport enum ConnectionTypeCategory {\r\n\r\n  // standard database\r\n  CTC_Database = 'database',\r\n\r\n  // 'More Items ...' meta item\r\n  CTC_More = 'more',\r\n\r\n  // Other file types\r\n  CTC_Other = 'other',\r\n\r\n  // invalid connection category\r\n  CTC_Invalid = 'invalid'\r\n}\r\n\r\n// a logical grouping of connection types displayed by the connection UI\r\nexport enum ConnectionTypeGroup {\r\n\r\n  // in a file\r\n  CTG_File = 'file',\r\n\r\n  // on a server\r\n  CTG_Server = 'server',\r\n\r\n  // on a recent server\r\n  CTG_MruServer = 'mru-server',\r\n\r\n  // invalid group\r\n  CTG_Invalid = 'invalid'\r\n}\r\n\r\n// The type of metadata a column contains\r\nexport enum CubeMetadataCategory {\r\n\r\n  // cube's name\r\n  CMC_Name = 'name',\r\n\r\n  // cube's description\r\n  CMC_Description = 'description',\r\n\r\n  // cube's last updated timestamp\r\n  CMC_LastUpdated = 'last-updated',\r\n\r\n  // invalid\r\n  CMC_Invalid = 'invalid'\r\n}\r\n\r\n// The type of widget to display to the user when they are specifying connection info\r\nexport enum ConnectionWidgetType {\r\n\r\n  // show the join area\r\n  CWT_JoinArea = 'join-area',\r\n\r\n  // show the cube selection ui\r\n  CWT_CubeSelection = 'cube-selection',\r\n\r\n  // show the google analytics ui\r\n  CWT_GoogleAnalytics = 'google-analytics',\r\n\r\n  // show the tableau server ui\r\n  CWT_TableauServer = 'tableau-server',\r\n\r\n  // do not show any connection widget\r\n  CWT_NoWidget = 'no-widget',\r\n\r\n  // invalid\r\n  CWT_Invalid = 'invalid'\r\n}\r\n\r\n// The type of google analytics basic info\r\nexport enum GoogleBasicInfoType {\r\n\r\n  // google analytics account\r\n  GA_Account = 'ga-account',\r\n\r\n  // google analytics property\r\n  GA_Property = 'ga-property',\r\n\r\n  // google analytics view\r\n  GA_View = 'ga-view',\r\n\r\n  // invalid\r\n  GA_Invalid = 'invalid'\r\n}\r\n\r\n// The way in which a piece of connection information is specified\r\nexport enum ConnectionSpecificationType {\r\n\r\n  // Uses a combo box\r\n  CST_ComboBox = 'combo-box',\r\n\r\n  // Uses a line edit\r\n  CST_LineEdit = 'line-edit',\r\n\r\n  // Uses a line edit with a browse button next to it\r\n  CST_LineEditBrowse = 'line-edit-browse',\r\n\r\n  // invalid\r\n  CST_Invalid = 'invalid'\r\n}\r\n\r\n// GA Date Range\r\nexport enum DateRange {\r\n\r\n  // \r\n  DateRangeFirst = 'date-range-first',\r\n\r\n  // \r\n  DateRangeLast30Days = 'date-range-last30',\r\n\r\n  // \r\n  DateRangeToday = 'date-range-today',\r\n\r\n  // \r\n  DateRangeYesterday = 'date-range-yesterday',\r\n\r\n  // \r\n  DateRangeLastWeek = 'date-range-last-week',\r\n\r\n  // \r\n  DateRangeLastMonth = 'date-range-last-month',\r\n\r\n  // \r\n  DateRangeLastYear = 'date-range-last-year',\r\n\r\n  // \r\n  DateRangeThisWeekToYesterday = 'date-range-this-week-to-yesterday',\r\n\r\n  // \r\n  DateRangeThisMonthToYesterday = 'date-range-this-month-to-yesterday',\r\n\r\n  // \r\n  DateRangeThisYearToYesterday = 'date-range-this-year-to-yesterday',\r\n\r\n  // \r\n  DateRangeLastWeekToYesterday = 'date-range-last-week-to-yesterday',\r\n\r\n  // \r\n  DateRangeLastMonthToYesterday = 'date-range-last-month-to-yesterday',\r\n\r\n  // \r\n  DateRangeLastYearToYesterday = 'date-range-last-year-to-yesterday',\r\n\r\n  // \r\n  DateRangeFixedRange = 'date-range-fixed-range',\r\n\r\n  // \r\n  DateRangeFixedStart = 'date-range-fixed-start',\r\n\r\n  // \r\n  DateRangeCount = 'date-range-count'\r\n}\r\n\r\n// Specifies the type of widget to show in ConnectServerWidget\r\nexport enum ConnectServerWidgetType {\r\n\r\n  // invalid\r\n  CSWT_Invalid = 'invalid',\r\n\r\n  // microsoft access\r\n  CSWT_Access = 'access',\r\n\r\n  // generic odbc\r\n  CSWT_ODBC = 'odbc',\r\n\r\n  // cubes\r\n  CSWT_Cube = 'cube',\r\n\r\n  // relational data sources\r\n  CSWT_Relational = 'relational'\r\n}\r\n\r\n// \r\nexport enum AuthenticationEnumsMode {\r\n\r\n  // no authentication widget\r\n  AuthModeNone = 'auth-mode-none',\r\n\r\n  // username and password\r\n  AuthModeBasic = 'auth-mode-basic',\r\n\r\n  // username and password can be blank\r\n  AuthModeBasicNoValidateFields = 'auth-mode-basic-no-validate-fields',\r\n\r\n  // only username\r\n  AuthModeBasicUserNameOnly = 'auth-mode-basic-username-only',\r\n\r\n  // aws access key and secret ID\r\n  AuthModeBasicAWS = 'auth-mode-basic-aws',\r\n\r\n  // username, password, and a list of AuthOptions with radio buttons\r\n  AuthModeRadio = 'auth-mode-radio',\r\n\r\n  // Like AuthModeRadio, but enable username/password even for integrated auth\r\n  AuthModeRadioUnindented = 'auth-mode-radio-unindented',\r\n\r\n  // username, password, and a list of AuthOptions with a combobox\r\n  AuthModeComboBox = 'auth-mode-combobox',\r\n\r\n  // Like AuthModeCombobox, but with option not requiring username/password\r\n  AuthModeComboBoxIntegrated = 'auth-mode-combobox-integrated',\r\n\r\n  // driver, authentication, username, realm, etc\r\n  AuthModeHive = 'auth-mode-hive',\r\n\r\n  // none, azure marketplace account, explicit\r\n  AuthModeOData = 'auth-mode-odata',\r\n\r\n  // edition, authentication, sso domain, etc\r\n  AuthModeSharePoint = 'auth-mode-sharepoint',\r\n\r\n  // username, password, client, & language\r\n  AuthModeSAPBW = 'auth-mode-sapbw',\r\n\r\n  // Ability to switch between two different auth modes each in their own modal dialogs (basic and oauth)\r\n  AuthModeSwitchModal = 'auth-mode-switch-modal'\r\n}\r\n\r\n// \r\nexport enum AuthenticationEnumsReconnectMode {\r\n\r\n  // Auth not needed for reconnect\r\n  ReconnectModeNone = 'reconnect-mode-none',\r\n\r\n  // Username and password\r\n  ReconnectModeBasic = 'reconnect-mode-basic',\r\n\r\n  // Access file\r\n  ReconnectModeAccess = 'reconnect-mode-access',\r\n\r\n  // Microsoft Azure Data Market (OData)\r\n  ReconnectModeDataMarket = 'reconnect-mode-data-market',\r\n\r\n  // Google OAuth\r\n  ReconnectModeGoogleOAuth = 'reconnect-mode-google-oauth',\r\n\r\n  // SalesforceOAuth, with the option of username/password auth\r\n  ReconnectModeSalesforceOAuth = 'reconnect-mode-salesforce-oauth',\r\n\r\n  // Web data connector\r\n  ReconnectModeWebData = 'reconnect-mode-web-data'\r\n}\r\n\r\n// \r\nexport enum AuthenticationEnumsAuthOption {\r\n\r\n  // FIRST\r\n  AuthExplicit = 'auth-option-explicit',\r\n\r\n  // \r\n  AuthExplicitUnindented = 'auth-option-explicit-unindented',\r\n\r\n  // \r\n  AuthUseWindows = 'auth-option-use-windows',\r\n\r\n  // \r\n  AuthUseWindowsPreferred = 'auth-option-windows-preferred',\r\n\r\n  // \r\n  AuthTeradata = 'auth-option-teradata',\r\n\r\n  // \r\n  AuthLDAP = 'auth-option-ldap',\r\n\r\n  // \r\n  AuthVirtualNode = 'auth-option-virtual-node',\r\n\r\n  // \r\n  AuthODataAccount = 'auth-option-odata',\r\n\r\n  // \r\n  AuthNone = 'auth-option-none',\r\n\r\n  // \r\n  AuthKerberos = 'auth-option-kerberos',\r\n\r\n  // Introduced for Kerberos with fallback, recognizing that the db may or may not be on Windows\r\n  AuthIntegrated = 'auth-option-integrated',\r\n\r\n  // \r\n  AuthUsername = 'auth-option-username',\r\n\r\n  // \r\n  AuthUsernameAndPassword = 'auth-option-username-and-password',\r\n\r\n  // \r\n  AuthSSL = 'auth-option-ssl',\r\n\r\n  // \r\n  AuthHDIEmulator = 'auth-hdi-emulator',\r\n\r\n  // \r\n  AuthHDIService = 'auth-hdi-service',\r\n\r\n  // \r\n  AuthHTTP = 'auth-http',\r\n\r\n  // \r\n  AuthHTTPS = 'auth-https',\r\n\r\n  // \r\n  AuthAccessNoSecurity = 'auth-option-access-no',\r\n\r\n  // \r\n  AuthAccessYesSecurity = 'auth-option-access-yes',\r\n\r\n  // \r\n  AuthOAuth = 'auth-oauth',\r\n\r\n  // \r\n  AuthForms = 'auth-forms',\r\n\r\n  // \r\n  AuthThirdPartySSO = 'auth-third-party-SSO',\r\n\r\n  // LAST\r\n  AuthInvalid = 'auth-option-invalid',\r\n\r\n  // \r\n  AuthSAMLIdP = 'auth-option-saml-idp'\r\n}\r\n\r\n// data source validation modes\r\nexport enum DataSourceParserValidationMode {\r\n\r\n  // \r\n  WorkbookLoadValidation = 'workbook-load-validation',\r\n\r\n  // \r\n  AutoValidation = 'auto-validation',\r\n\r\n  // \r\n  ForceValidation = 'force-validation',\r\n\r\n  // \r\n  PreventValidation = 'prevent-validation',\r\n\r\n  // \r\n  PreventValidationAndThrow = 'prevent-validation-and-throw'\r\n}\r\n\r\n// Enum for DataGrid/MetadataGrid fields reordering\r\nexport enum FieldOrderType {\r\n\r\n  // \r\n  DATASOURCE_ORDER = 'datasource-order',\r\n\r\n  // \r\n  ALPHA_PER_TABLE = 'alpha-per-table',\r\n\r\n  // \r\n  ALPHABETICAL_ORDER = 'alphabetical-order',\r\n\r\n  // \r\n  CUSTOM_ORDER = 'custom-order'\r\n}\r\n\r\n// \r\nexport enum LineInterpolationMode {\r\n\r\n  // \r\n  LIM_Linear = 'lim-linear',\r\n\r\n  // \r\n  LIM_Step = 'lim-step',\r\n\r\n  // \r\n  LIM_Jump = 'lim-jump'\r\n}\r\n\r\n// \r\nexport enum LineMarkerPosition {\r\n\r\n  // \r\n  LMP_Left = 'lmp-left',\r\n\r\n  // \r\n  LMP_Center = 'lmp-center',\r\n\r\n  // \r\n  LMP_Right = 'lmp-right'\r\n}\r\n\r\n// \r\nexport enum FolderRole {\r\n\r\n  // \r\n  FOLDER_DIMENSIONS = 'dimensions',\r\n\r\n  // \r\n  FOLDER_MEASURES = 'measure',\r\n\r\n  // \r\n  FOLDER_GROUPS = 'groups',\r\n\r\n  // \r\n  FOLDER_PARAMETERS = 'parameters'\r\n}\r\n\r\n// \r\nexport enum FieldTypeIconSet {\r\n\r\n  // \r\n  FT_SET_ALL = 'all',\r\n\r\n  // \r\n  FT_SET_CUBE_MEASURES = 'cube-measures',\r\n\r\n  // \r\n  FT_SET_CUBE_DIMENSIONS = 'cube-dimensions'\r\n}\r\n\r\n// \r\nexport enum FieldPivotStrategy {\r\n\r\n  // \r\n  PIVOT_ON_KEY = 'pivot-on-key',\r\n\r\n  // \r\n  PIVOT_ON_ALIAS = 'pivot-on-alias'\r\n}\r\n\r\n// \r\nexport enum AliasType {\r\n\r\n  // \r\n  ALIAS_NOTSET = 'alias-not-set',\r\n\r\n  // \r\n  ALIAS_BEGIN = 'alias-begin',\r\n\r\n  // \r\n  ALIAS_KEY = 'alias-key',\r\n\r\n  // \r\n  ALIAS_KEY_NAME = 'alias-key-name',\r\n\r\n  // \r\n  ALIAS_KEY_MEDNAME = 'alias-key-medname',\r\n\r\n  // \r\n  ALIAS_KEY_LONGNAME = 'alias-key-longname',\r\n\r\n  // \r\n  ALIAS_NAME = 'alias-name',\r\n\r\n  // \r\n  ALIAS_NAME_KEY = 'alias-name-key',\r\n\r\n  // \r\n  ALIAS_MEDNAME = 'alias-medname',\r\n\r\n  // \r\n  ALIAS_MEDNAME_KEY = 'alias-medname-key',\r\n\r\n  // \r\n  ALIAS_LONGNAME = 'alias-longname',\r\n\r\n  // \r\n  ALIAS_LONGNAME_KEY = 'alias-longname-key',\r\n\r\n  // \r\n  ALIAS_END = 'alias-end'\r\n}\r\n\r\n// \r\nexport enum AliasTypes {\r\n\r\n  // \r\n  MASK_ALIAS_KEY = 'mask-alias-key',\r\n\r\n  // \r\n  MASK_ALIAS_NAME = 'mask-alias-name',\r\n\r\n  // \r\n  MASK_ALIAS_MEDNAME = 'mask-alias-medname',\r\n\r\n  // \r\n  MASK_ALIAS_LONGNAME = 'mask-alias-longname'\r\n}\r\n\r\n// \r\nexport enum FieldRole {\r\n\r\n  // \r\n  ROLE_DIMENSION = 'dimension',\r\n\r\n  // \r\n  ROLE_MEASURE = 'measure',\r\n\r\n  // \r\n  ROLE_UNKNOWN = 'unknown'\r\n}\r\n\r\n// \r\nexport enum FieldType {\r\n\r\n  // \r\n  TYPE_QUANTITATIVE = 'quantitative',\r\n\r\n  // \r\n  TYPE_ORDINAL = 'ordinal',\r\n\r\n  // \r\n  TYPE_NOMINAL = 'nominal',\r\n\r\n  // \r\n  TYPE_UNKNOWN = 'unknown'\r\n}\r\n\r\n// \r\nexport enum DataSourceOrder {\r\n\r\n  // \r\n  DSO_ALPHABETIC = 'dso-alphabetic',\r\n\r\n  // \r\n  DSO_ORDINAL = 'dso-ordinal'\r\n}\r\n\r\n// Where the column comes from\r\nexport enum ColumnClass {\r\n\r\n  // A metadata column (O or Q Measures)\r\n  COL_METADATA = 'col-metadata',\r\n\r\n  // A physical column on the database\r\n  COL_DATABASE = 'col-database',\r\n\r\n  // A numberic bin (a special kind of calculated column)\r\n  COL_NUMERICBIN = 'col-numericbin',\r\n\r\n  // A Categorical bin (group)\r\n  COL_CATEGORICALBIN = 'col-categoricalbin',\r\n\r\n  // A column instance\r\n  COL_INSTANCE = 'col-instance',\r\n\r\n  // A (raw) mdx calculated column\r\n  COL_MDXCALC = 'col-mdxcalc',\r\n\r\n  // A user-defined calculated column, Tableau expression syntax\r\n  COL_USERCALC = 'col-usercalc',\r\n\r\n  // A column that would have been COL_DATABASE, but the underlying database column does not exist\r\n  COL_DANGLING = 'col-dangling',\r\n\r\n  // A column that contains local supplied data (e.g. Latitude)\r\n  COL_LOCALDATA = 'col-localdata',\r\n\r\n  // A column that contains a visual model attribute (e.g. PaneIndex, Color, ...)\r\n  COL_VISUALDATA = 'col-visualdata',\r\n\r\n  // A column that's a Group (a \" Set \" in UI terminology)\r\n  COL_GROUP = 'col-group'\r\n}\r\n\r\n// \r\nexport enum VTAggType {\r\n\r\n  // \r\n  VTAGG_SUM = 'sum',\r\n\r\n  // \r\n  VTAGG_AVG = 'avg',\r\n\r\n  // \r\n  VTAGG_MIN = 'min',\r\n\r\n  // \r\n  VTAGG_MAX = 'max',\r\n\r\n  // \r\n  VTAGG_SERVER = 'server',\r\n\r\n  // \r\n  VTAGG_NONE = 'none',\r\n\r\n  // \r\n  VTAGG_DEFAULT = 'default'\r\n}\r\n\r\n// \r\nexport enum EntityType {\r\n\r\n  // \r\n  NoEnumerationEntity = 'no-enumeration-entity',\r\n\r\n  // \r\n  DatabaseEntity = 'database-entity',\r\n\r\n  // \r\n  SchemaEntity = 'schema-entity',\r\n\r\n  // \r\n  TableEntity = 'table-entity'\r\n}\r\n\r\n// \r\nexport enum PickEntitySearchType {\r\n\r\n  // \r\n  PickEntitySearchType_StartsWith = 'starts-with',\r\n\r\n  // \r\n  PickEntitySearchType_Contains = 'contains',\r\n\r\n  // \r\n  PickEntitySearchType_ExactMatch = 'exact-match',\r\n\r\n  // \r\n  PickEntitySearchType_DEFAULT = 'default'\r\n}\r\n\r\n// Parsing methods and structures.\r\nexport enum ExpressionOp {\r\n\r\n  // \r\n  LogicalOr = 'op-logical-or',\r\n\r\n  // \r\n  LogicalAnd = 'op-logical-and',\r\n\r\n  // \r\n  LogicalNot = 'op-logical-not',\r\n\r\n  // \r\n  BitwiseXOr = 'op-bitwise-xor',\r\n\r\n  // \r\n  BitwiseOr = 'op-bitwise-or',\r\n\r\n  // \r\n  Equals = 'op-equals',\r\n\r\n  // \r\n  Greater = 'op-greater',\r\n\r\n  // \r\n  Less = 'op-less',\r\n\r\n  // \r\n  GEqual = 'op-gequal',\r\n\r\n  // \r\n  LEqual = 'op-lequal',\r\n\r\n  // \r\n  NEqual = 'op-nequal',\r\n\r\n  // \r\n  Plus = 'op-plus',\r\n\r\n  // \r\n  Minus = 'op-minus',\r\n\r\n  // \r\n  BitwiseAnd = 'op-bitwise-and',\r\n\r\n  // \r\n  Multiply = 'op-multiply',\r\n\r\n  // \r\n  Divide = 'op-divide',\r\n\r\n  // \r\n  Modulo = 'op-modulo',\r\n\r\n  // \r\n  Power = 'op-power',\r\n\r\n  // \r\n  Positive = 'op-positive',\r\n\r\n  // \r\n  Negative = 'op-negative',\r\n\r\n  // \r\n  BitwiseNot = 'op-bitwise-not',\r\n\r\n  // \r\n  Column = 'op-column',\r\n\r\n  // \r\n  String = 'op-string',\r\n\r\n  // \r\n  Number = 'op-number',\r\n\r\n  // \r\n  Date = 'op-date',\r\n\r\n  // \r\n  Boolean = 'op-boolean',\r\n\r\n  // \r\n  Funcall = 'op-funcall',\r\n\r\n  // \r\n  LParen = 'op-lparen',\r\n\r\n  // \r\n  RParen = 'op-rparen',\r\n\r\n  // \r\n  Comma = 'op-comma',\r\n\r\n  // \r\n  Ident = 'op-ident',\r\n\r\n  // \r\n  Null = 'op-null',\r\n\r\n  // \r\n  If = 'op-if',\r\n\r\n  // \r\n  Elseif = 'op-elseif',\r\n\r\n  // \r\n  Case = 'op-case',\r\n\r\n  // \r\n  When = 'op-when',\r\n\r\n  // \r\n  Then = 'op-then',\r\n\r\n  // \r\n  Else = 'op-else',\r\n\r\n  // \r\n  EndExpr = 'op-endexpr',\r\n\r\n  // \r\n  Whitespace = 'op-whitespace',\r\n\r\n  // \r\n  Comment = 'op-comment',\r\n\r\n  // \r\n  LBrace = 'op-lbrace',\r\n\r\n  // \r\n  RBrace = 'op-rbrace',\r\n\r\n  // \r\n  Colon = 'op-colon',\r\n\r\n  // \r\n  Bar = 'op-bar',\r\n\r\n  // \r\n  Txtype = 'op-txtype',\r\n\r\n  // \r\n  End = 'op-end',\r\n\r\n  // \r\n  RBrackets = 'op-rbrackets',\r\n\r\n  // used to represent invalid tokens\r\n  Invalid = 'op-invalid'\r\n}\r\n\r\n// tri-state bool\r\nexport enum TriBool {\r\n\r\n  // \r\n  TB_Invalid = 'tribool-invalid',\r\n\r\n  // \r\n  TB_False = 'tribool-false',\r\n\r\n  // \r\n  TB_True = 'tribool-true'\r\n}\r\n\r\n// table calc reference options set\r\nexport enum ReferenceOptionsSet {\r\n\r\n  // \r\n  ROS_Relative = 'reference-options-set-relative',\r\n\r\n  // \r\n  ROS_Fixed = 'reference-options-set-fixed',\r\n\r\n  // \r\n  ROS_Parameter = 'reference-options-set-parameter',\r\n\r\n  // \r\n  ROS_None = 'reference-options-set-none'\r\n}\r\n\r\n// widget state\r\nexport enum WidgetState {\r\n\r\n  // \r\n  Hidden = 'widget-state-hidden',\r\n\r\n  // \r\n  Disabled = 'widget-state-disabled',\r\n\r\n  // \r\n  Enabled = 'widget-state-enabled'\r\n}\r\n\r\n// rank type\r\nexport enum RankType {\r\n\r\n  // \r\n  Competition = 'rank-type-competition',\r\n\r\n  // \r\n  ModifiedCompetition = 'rank-type-modified-competition',\r\n\r\n  // \r\n  Dense = 'rank-type-dense',\r\n\r\n  // \r\n  Unique = 'rank-type-unique'\r\n}\r\n\r\n// \r\nexport enum TableCalcCommandType {\r\n\r\n  // \r\n  TableCalcCommandClear = 'clear'\r\n}\r\n\r\n// \r\nexport enum CalcNestingLevel {\r\n\r\n  // \r\n  Primary = 'primary',\r\n\r\n  // used only for type != TC_CUSTOM\r\n  Secondary = 'secondary',\r\n\r\n  // used only for type == TC_CUSTOM\r\n  Nested = 'nested'\r\n}\r\n\r\n// \r\nexport enum DecimalMode {\r\n\r\n  // \r\n  DecimalModeAutomatic = 'automatic',\r\n\r\n  // \r\n  DecimalModeManual = 'manual'\r\n}\r\n\r\n// \r\nexport enum TableCalcOrderingType {\r\n\r\n  // Advanced...\r\n  OTField = 'field',\r\n\r\n  // Table (Across)\r\n  OTRows = 'rows',\r\n\r\n  // Table (Down)\r\n  OTColumns = 'columns',\r\n\r\n  // Table (Across then Down)\r\n  OTTable = 'table',\r\n\r\n  // Table (Down then Across)\r\n  OTTableColumnPrecedence = 'table-column-precedence',\r\n\r\n  // Pane Across\r\n  OTRowInPane = 'row-in-pane',\r\n\r\n  // Pane (Down)\r\n  OTColumnInPane = 'column-in-pane',\r\n\r\n  // Pane (Across then Down)\r\n  OTPane = 'pane',\r\n\r\n  // Pane (Down then Across)\r\n  OTPaneColumnPrecedence = 'pane-column-precedence',\r\n\r\n  // Cell\r\n  OTCellInPane = 'cell-in-pane'\r\n}\r\n\r\n// \r\nexport enum TableCalcSortMode {\r\n\r\n  // \r\n  SM_Automatic = 'sort-mode-automatic',\r\n\r\n  // \r\n  SM_Custom = 'sort-mode-custom'\r\n}\r\n\r\n// \r\nexport enum TableCalcTableCalcType {\r\n\r\n  // none (used to initialize variables)\r\n  TC_NONE = 'none',\r\n\r\n  // Running Total\r\n  TC_CUMULATIVE = 'cumulative',\r\n\r\n  // Moving Calculation\r\n  TC_WINDOW = 'window',\r\n\r\n  // Difference From\r\n  TC_DIFF = 'diff',\r\n\r\n  // Percent Difference From\r\n  TC_PCTDIFF = 'pct-diff',\r\n\r\n  // Percent From\r\n  TC_PCTVALUE = 'pct-value',\r\n\r\n  // Percent Of Total\r\n  TC_PCTTOTAL = 'pct-total',\r\n\r\n  // Rank\r\n  TC_RANK = 'rank',\r\n\r\n  // Percentile\r\n  TC_PCTRANK = 'pct-rank',\r\n\r\n  // Custom\r\n  TC_CUSTOM = 'custom'\r\n}\r\n\r\n// \r\nexport enum QuickTableCalcCommandType {\r\n\r\n  // \r\n  QuickTableCalcCommandRunTotal = 'run-total',\r\n\r\n  // \r\n  QuickTableCalcCommandDifference = 'difference',\r\n\r\n  // \r\n  QuickTableCalcCommandPctDiff = 'pct-diff',\r\n\r\n  // \r\n  QuickTableCalcCommandPctTotal = 'pct-total',\r\n\r\n  // \r\n  QuickTableCalcCommandRank = 'rank',\r\n\r\n  // \r\n  QuickTableCalcCommandPctRank = 'pct-rank',\r\n\r\n  // \r\n  QuickTableCalcCommandMovingAvg = 'moving-avg',\r\n\r\n  // \r\n  QuickTableCalcCommandYtd = 'ytd',\r\n\r\n  // \r\n  QuickTableCalcCommandCgr = 'cgr',\r\n\r\n  // \r\n  QuickTableCalcCommandYOverY = 'y-over-y',\r\n\r\n  // \r\n  QuickTableCalcCommandYtdGrowth = 'ytd-growth',\r\n\r\n  // \r\n  QuickTableCalcCommandCustom = 'custom'\r\n}\r\n\r\n// \r\nexport enum TableCalcAddressCommandType {\r\n\r\n  // \r\n  TableCalcAddressCommandRel = 'rel',\r\n\r\n  // \r\n  TableCalcAddressCommandAbs = 'abs',\r\n\r\n  // \r\n  TableCalcAddressCommandParam = 'param',\r\n\r\n  // \r\n  TableCalcAddressCommandMore = 'more'\r\n}\r\n\r\n// relative addressing\r\nexport enum TableCalcRelativeAddress {\r\n\r\n  // \r\n  RelAddrFirst = 'relative-address-first',\r\n\r\n  // \r\n  RelAddrPrevious = 'relative-address-previous',\r\n\r\n  // \r\n  RelAddrNext = 'relative-address-next',\r\n\r\n  // \r\n  RelAddrLast = 'relative-address-last'\r\n}\r\n\r\n// \r\nexport enum CategoricalBinItemType {\r\n\r\n  // \r\n  Unbinned = 'unbinned',\r\n\r\n  // \r\n  BinMember = 'categorical-bin-member',\r\n\r\n  // \r\n  Bin = 'categorical-bin'\r\n}\r\n\r\n// The class properties\r\nexport enum CredentialTypePropertiesFlag {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  GenericAuthClass = 'generic-auth-class',\r\n\r\n  // \r\n  ProviderClass = 'provider-class',\r\n\r\n  // \r\n  DataConnectionClass = 'data-connection-class'\r\n}\r\n\r\n// The connector type\r\nexport enum ConnectorType {\r\n\r\n  // \r\n  Invalid = 'invalid',\r\n\r\n  // \r\n  WebDataConnector = 'web-data-connector',\r\n\r\n  // \r\n  CloudFileConnector = 'cloud-file-connector',\r\n\r\n  // \r\n  LegacyConnector = 'legacy-connector'\r\n}\r\n\r\n// \r\nexport enum TablePillIcon {\r\n\r\n  // \r\n  ListItem = 'list-item',\r\n\r\n  // \r\n  Sheet = 'sheet',\r\n\r\n  // \r\n  FoundTable = 'found-table',\r\n\r\n  // \r\n  NamedRange = 'named-range',\r\n\r\n  // \r\n  StoredProcedure = 'stored-procedure'\r\n}\r\n\r\n// \r\nexport enum JoinValidationError {\r\n\r\n  // \r\n  JVE_NoError = 'no-error',\r\n\r\n  // \r\n  JVE_EmptyClause = 'empty-clause',\r\n\r\n  // \r\n  JVE_TypeMismatch = 'type-mismatch',\r\n\r\n  // \r\n  JVE_InvalidField = 'invalid-field',\r\n\r\n  // \r\n  JVE_BadClause = 'bad-clause',\r\n\r\n  // \r\n  JVE_BadInputRelation = 'bad-input-relation',\r\n\r\n  // \r\n  JVE_RepeatedFieldReferences = 'repeated-field-references',\r\n\r\n  // \r\n  JVE_UnsupportedJoinType = 'unsupported-join-type',\r\n\r\n  // \r\n  JVE_InvalidCalculation = 'invalid-calculation',\r\n\r\n  // \r\n  JVE_NonSpatialType = 'non-spatial-type',\r\n\r\n  // \r\n  JVE_NonSpatialComparison = 'non-spatial-comp',\r\n\r\n  // \r\n  JVE_Unknown = 'unknown'\r\n}\r\n\r\n// \r\nexport enum ConnectionTypeEnum {\r\n\r\n  // -d-s is used to force the enum generator to generate DS with capital letters in .cs just like the .cpp\r\n  InvalidDS = 'invalid-d-s',\r\n\r\n  // \r\n  FileDS = 'file-d-s',\r\n\r\n  // \r\n  ServerDS = 'server-d-s',\r\n\r\n  // \r\n  InternetDS = 'internet-d-s',\r\n\r\n  // \r\n  TableauServerDS = 'tableau-server-d-s'\r\n}\r\n\r\n// \r\nexport enum ConnectionErrorStage {\r\n\r\n  // \r\n  Unknown = 'unknown',\r\n\r\n  // \r\n  CreateProtocolFailed = 'create-protocol-failed',\r\n\r\n  // \r\n  LoadMetadataFailed = 'load-metadata-failed'\r\n}\r\n\r\n// \r\nexport enum SortDirection {\r\n\r\n  // ascending\r\n  ST_ASC = 'asc',\r\n\r\n  // descending\r\n  ST_DESC = 'desc'\r\n}\r\n\r\n// \r\nexport enum SortType {\r\n\r\n  // Use the defined ordering\r\n  ST_NATURAL = 'data-source-order',\r\n\r\n  // Alphabetic/numeric ordering of data\r\n  ST_ALPHABETIC = 'alpha',\r\n\r\n  // Specify a secondary field\r\n  ST_COMPUTED = 'field',\r\n\r\n  // Manually defined ordering\r\n  ST_MANUAL = 'manual'\r\n}\r\n\r\n// \r\nexport enum SortEnd {\r\n\r\n  // \r\n  ST_TOP = 'top',\r\n\r\n  // \r\n  ST_BOTTOM = 'bottom'\r\n}\r\n\r\n// Enumeration for the type of join connecting two tables\r\nexport enum SQLJoinType {\r\n\r\n  // \r\n  SQL_InnerJoin = 'sql-inner-join',\r\n\r\n  // \r\n  SQL_LeftJoin = 'sql-left-join',\r\n\r\n  // \r\n  SQL_RightJoin = 'sql-right-join',\r\n\r\n  // \r\n  SQL_FullJoin = 'sql-full-join',\r\n\r\n  // \r\n  SQL_CrossJoin = 'sql-cross-join'\r\n}\r\n\r\n// The result of parsing and setting a data value for a property of a quantitative axis.\r\nexport enum SetAxisDataValueResult {\r\n\r\n  // \r\n  Success = 'set-axis-data-value-result-success',\r\n\r\n  // \r\n  ParseFailure = 'set-axis-data-value-result-parse-failure',\r\n\r\n  // \r\n  ValueFailure = 'set-axis-data-value-result-value-failure'\r\n}\r\n\r\n// The type of an axis' extent\r\nexport enum AxisExtentType {\r\n\r\n  // \r\n  Automatic = 'axis-extent-automatic',\r\n\r\n  // \r\n  Uniform = 'axis-extent-uniform',\r\n\r\n  // \r\n  Independent = 'axis-extent-independent',\r\n\r\n  // \r\n  Fixed = 'axis-extent-fixed'\r\n}\r\n\r\n// Enumeration of units tick spacing can take\r\nexport enum TickSpacingUnits {\r\n\r\n  // \r\n  NoUnits = 'no-units',\r\n\r\n  // \r\n  Years = 'years',\r\n\r\n  // \r\n  Quarters = 'quarters',\r\n\r\n  // \r\n  Months = 'months',\r\n\r\n  // \r\n  Weeks = 'weeks',\r\n\r\n  // \r\n  Days = 'days',\r\n\r\n  // \r\n  Hours = 'hours',\r\n\r\n  // \r\n  Minutes = 'minutes',\r\n\r\n  // \r\n  Seconds = 'seconds'\r\n}\r\n\r\n// Enumeration of whether totals are included in or excluded from the color encoding\r\nexport enum TotalsInclusion {\r\n\r\n  // Totals included in color encoding\r\n  IncludeTotals = 'include-totals',\r\n\r\n  // Totals excluded from color encoding\r\n  ExcludeTotals = 'exclude-totals'\r\n}\r\n\r\n// How tick marks are being calculated\r\nexport enum TickMarkState {\r\n\r\n  // \r\n  TicksAutomatic = 'ticks-automatic',\r\n\r\n  // \r\n  TicksManual = 'ticks-manual',\r\n\r\n  // \r\n  TicksNone = 'ticks-None'\r\n}\r\n\r\n// Setting for type of axis range\r\nexport enum AxisRangeType {\r\n\r\n  // \r\n  AutomaticRange = 'automatic-range',\r\n\r\n  // \r\n  UniformRange = 'uniform-range',\r\n\r\n  // \r\n  IndependentRange = 'independent-range',\r\n\r\n  // \r\n  FixedRange = 'fixed-range',\r\n\r\n  // \r\n  FixedMin = 'fixed-min',\r\n\r\n  // \r\n  FixedMax = 'fixed-max',\r\n\r\n  // \r\n  FixedMinUniformMax = 'fixed-min-uniform-max',\r\n\r\n  // \r\n  FixedMinIndependentMax = 'fixed-min-independent-max',\r\n\r\n  // \r\n  FixedMaxUniformMin = 'fixed-max-uniform-min',\r\n\r\n  // \r\n  FixedMaxIndependentMin = 'fixed-max-independent-min',\r\n\r\n  // \r\n  FixedRangeOrdinal = 'fixed-range-ordinal'\r\n}\r\n\r\n// represents type of widget on the toolbar of rich text editor\r\nexport enum RichTextEditorWidgetKey {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  FontSize = 'fontsize',\r\n\r\n  // \r\n  FontName = 'fontname',\r\n\r\n  // \r\n  FontColor = 'color',\r\n\r\n  // \r\n  Bold = 'bold',\r\n\r\n  // \r\n  Italic = 'italic',\r\n\r\n  // \r\n  Underline = 'underline',\r\n\r\n  // \r\n  AlignLeft = 'justifyleft',\r\n\r\n  // \r\n  AlignCenter = 'justifycenter',\r\n\r\n  // \r\n  AlignRight = 'justifyright',\r\n\r\n  // \r\n  ClearFormatting = 'clearformatting',\r\n\r\n  // \r\n  TableauKeywords = 'tableaukeywords'\r\n}\r\n\r\n// \r\nexport enum CellSizeChange {\r\n\r\n  // \r\n  CSC_Taller = 'taller',\r\n\r\n  // \r\n  CSC_Shorter = 'shorter',\r\n\r\n  // \r\n  CSC_Wider = 'wider',\r\n\r\n  // \r\n  CSC_Narrower = 'narrower',\r\n\r\n  // \r\n  CSC_Bigger = 'bigger',\r\n\r\n  // \r\n  CSC_Smaller = 'smaller'\r\n}\r\n\r\n// \r\nexport enum CellTypeEnum {\r\n\r\n  // \r\n  CLT_Square = 'square',\r\n\r\n  // \r\n  CLT_Text = 'text'\r\n}\r\n\r\n// represents type of formatting pres model\r\nexport enum TypeOfFormatItem {\r\n\r\n  // \r\n  FT_FormatItem = 'formatItem',\r\n\r\n  // \r\n  FT_FormatContainer = 'formatContainer',\r\n\r\n  // \r\n  FT_FormatControl = 'formatControl'\r\n}\r\n\r\n// represents type of formatting container\r\nexport enum TypeOfFormatContainer {\r\n\r\n  // \r\n  FT_FormatPane = 'formatPane',\r\n\r\n  // \r\n  FT_FormatSection = 'formatSection',\r\n\r\n  // \r\n  FT_CollapsibleSection = 'collapsibleSection',\r\n\r\n  // \r\n  FT_CompositeContainer = 'compositeContainer',\r\n\r\n  // \r\n  FT_UnitContainer = 'unitContainer',\r\n\r\n  // \r\n  FT_Tab = 'tab',\r\n\r\n  // \r\n  FT_TabGroup = 'tabGroup'\r\n}\r\n\r\n// represents type of formatting control\r\nexport enum TypeOfFormatControl {\r\n\r\n  // \r\n  FT_None = 'none',\r\n\r\n  // \r\n  FT_NumericControl = 'numeric-control',\r\n\r\n  // \r\n  FT_TextControl = 'text-control',\r\n\r\n  // \r\n  FT_ColorControl = 'color-control',\r\n\r\n  // \r\n  FT_SelectorControl = 'selector-control',\r\n\r\n  // \r\n  FT_ToggleControl = 'toggle-control'\r\n}\r\n\r\n// represents type of formatting widget\r\nexport enum FormatWidgetKey {\r\n\r\n  // \r\n  FWK_None = 'none',\r\n\r\n  // \r\n  FWK_FontFamily = 'fontFamily',\r\n\r\n  // \r\n  FWK_FontSize = 'fontSize',\r\n\r\n  // \r\n  FWK_ColorSwatch = 'colorSwatch',\r\n\r\n  // \r\n  FWK_Bold = 'bold',\r\n\r\n  // \r\n  FWK_Italics = 'italics',\r\n\r\n  // \r\n  FWK_Underline = 'underline',\r\n\r\n  // \r\n  FWK_LineVisibility = 'lineVisibility',\r\n\r\n  // \r\n  FWK_LinePattern = 'linePattern',\r\n\r\n  // \r\n  FWK_LineSize = 'lineSize',\r\n\r\n  // \r\n  FWK_NumberType = 'numericType',\r\n\r\n  // \r\n  FWK_DecimalPlaces = 'decimalPlaces',\r\n\r\n  // \r\n  FWK_ThousandsSeparator = 'thousandsSeparator',\r\n\r\n  // \r\n  FWK_NumericUnits = 'numericUnits'\r\n}\r\n\r\n// represents identifier for each node in format pane\r\nexport enum FormatNodeIdentifier {\r\n\r\n  // \r\n  Format_None_Key = 'none',\r\n\r\n  // \r\n  Format_Workbook_Key = 'workbook',\r\n\r\n  // \r\n  Format_Font_Key = 'font',\r\n\r\n  // \r\n  Format_Color_Key = 'color',\r\n\r\n  // \r\n  Format_Lines_Key = 'lines',\r\n\r\n  // \r\n  Format_FontAll_Key = 'font-all',\r\n\r\n  // \r\n  Format_FontAllControls_Key = 'font-all-controls',\r\n\r\n  // \r\n  Format_FontMore_Key = 'font-more',\r\n\r\n  // \r\n  Format_FontWorksheetTitles_Key = 'worksheet-titles',\r\n\r\n  // \r\n  Format_FontToolTip_Key = 'font-tooltip',\r\n\r\n  // \r\n  Format_FontWorksheet_Key = 'font-worksheet',\r\n\r\n  // \r\n  Format_FontDashTitles_Key = 'dash-titles',\r\n\r\n  // \r\n  Format_FontStoryTitles_Key = 'story-titles',\r\n\r\n  // \r\n  Format_FontTitlesControls_Key = 'titles-controls',\r\n\r\n  // \r\n  Format_FontTooltipControls_Key = 'tooltip-controls',\r\n\r\n  // \r\n  Format_FontWorksheetControls_Key = 'worksheet-controls',\r\n\r\n  // \r\n  Format_LineMore_Key = 'line-more',\r\n\r\n  // \r\n  Format_LineGrid_Key = 'line-grid',\r\n\r\n  // \r\n  Format_LineGridTabs_Key = 'line-grid-tabs',\r\n\r\n  // \r\n  Format_LineZero_Key = 'line-zero',\r\n\r\n  // \r\n  Format_LineZeroTabs_Key = 'line-zero-tabs',\r\n\r\n  // \r\n  Format_LineAxisTick_Key = 'line-axis-tick',\r\n\r\n  // \r\n  Format_LineAxisTickTabs_Key = 'line-axis-tick-tabs',\r\n\r\n  // \r\n  Format_LineAxisRuler_Key = 'line-axis-ruler',\r\n\r\n  // \r\n  Format_LineAxisRulerTabs_Key = 'line-axis-ruler-tabs',\r\n\r\n  // \r\n  Format_LineHeaderDivider_Key = 'line-header-divider',\r\n\r\n  // \r\n  Format_LineHeaderDividerTabs_Key = 'line-header-divider-tabs',\r\n\r\n  // \r\n  Format_LinePaneDivider_Key = 'line-paneDivider',\r\n\r\n  // \r\n  Format_LinePaneDividerTabs_Key = 'line-paneDivider-tabs',\r\n\r\n  // \r\n  Format_LineGridAll_Key = 'line-grid-all',\r\n\r\n  // \r\n  Format_LineGridRow_Key = 'line-grid-row',\r\n\r\n  // \r\n  Format_LineGridColumn_Key = 'line-grid-column',\r\n\r\n  // \r\n  Format_LineZeroAll_Key = 'line-zero-all',\r\n\r\n  // \r\n  Format_LineZeroRow_Key = 'line-zero-row',\r\n\r\n  // \r\n  Format_LineZeroColumn_Key = 'line-zero-column',\r\n\r\n  // \r\n  Format_LineAxisTickAll_Key = 'line-axis-tick-all',\r\n\r\n  // \r\n  Format_LineAxisTickRow_Key = 'line-axis-tick-row',\r\n\r\n  // \r\n  Format_LineAxisTickColumn_Key = 'line-axis-tick-column',\r\n\r\n  // \r\n  Format_LineAxisRulerAll_Key = 'line-axis-ruler-all',\r\n\r\n  // \r\n  Format_LineAxisRulerRow_Key = 'line-axis-ruler-row',\r\n\r\n  // \r\n  Format_LineAxisRulerColumn_Key = 'line-axis-ruler-column',\r\n\r\n  // \r\n  Format_LineReference_Key = 'line-reference',\r\n\r\n  // \r\n  Format_LineDrop_Key = 'line-drop',\r\n\r\n  // \r\n  Format_LineTrend_Key = 'line-trend',\r\n\r\n  // \r\n  Format_LineVisibility_Key = 'line-visibility',\r\n\r\n  // \r\n  Format_LinePattern_Key = 'line-pattern',\r\n\r\n  // \r\n  Format_LineWidth_Key = 'line-width',\r\n\r\n  // \r\n  Format_LineColor_Key = 'line-color',\r\n\r\n  // \r\n  Format_TickColor_Key = 'tick-color',\r\n\r\n  // \r\n  Format_BorderPattern_Key = 'border-pattern',\r\n\r\n  // \r\n  Format_BorderColor_Key = 'border-color',\r\n\r\n  // \r\n  Format_DividerColor_Key = 'divider-color',\r\n\r\n  // \r\n  Format_FontFamily_Key = 'font-family-key',\r\n\r\n  // \r\n  Format_FontSize_Key = 'font-size-key',\r\n\r\n  // \r\n  Format_Bold_Key = 'bold-key',\r\n\r\n  // \r\n  Format_Italics_Key = 'italics-key',\r\n\r\n  // \r\n  Format_Underline_Key = 'underline-key',\r\n\r\n  // \r\n  Format_FontColor_Key = 'font-color-key',\r\n\r\n  // \r\n  Format_Number_Container_Key = 'number-container',\r\n\r\n  // \r\n  Format_Number_Type_Key = 'number-container-type',\r\n\r\n  // \r\n  Format_Number_Units_Key = 'number-container-units',\r\n\r\n  // \r\n  Format_Number_Decimal_Key = 'number-container-decimal',\r\n\r\n  // \r\n  Format_Number_Thousands_Separator_Key = 'number-container-thousands-separator',\r\n\r\n  // \r\n  Format_FontPickerMinimal_Key = 'font-picker-minimal',\r\n\r\n  // \r\n  Format_FontPickerDefault_Key = 'font-picker-default',\r\n\r\n  // \r\n  Format_LinePickerDefault_Key = 'line-picker-default',\r\n\r\n  // \r\n  Format_LinePickerNoVis_Key = 'line-picker-no-visibility',\r\n\r\n  // \r\n  Format_LineAxisTickPicker_Key = 'line-axis-tick-picker'\r\n}\r\n\r\n// represents the color swatch that will be used in the ColorControlPresModel\r\nexport enum ColorSwatchType {\r\n\r\n  // \r\n  CST_Dark = 'dark-swatch',\r\n\r\n  // \r\n  CST_Light = 'light-swatch'\r\n}\r\n\r\n// represents the type of a style picker, affecting the preview rendering and, possibly, the layout\r\nexport enum PickerType {\r\n\r\n  // \r\n  PT_None = 'none',\r\n\r\n  // \r\n  PT_Font = 'font',\r\n\r\n  // \r\n  PT_Line = 'line',\r\n\r\n  // \r\n  PT_Number = 'number'\r\n}\r\n\r\n// \r\nexport enum UpdateScope {\r\n\r\n  // \r\n  US_Worksheet = 'worksheet',\r\n\r\n  // \r\n  US_Dashboard = 'dashboard',\r\n\r\n  // \r\n  US_QuickFilters = 'quick-filters',\r\n\r\n  // \r\n  US_Story = 'story'\r\n}\r\n\r\n// \r\nexport enum ParameterCtrlTypesDisplayMode {\r\n\r\n  // \r\n  MODE_TYPE_IN = 'type_in',\r\n\r\n  // \r\n  MODE_COMPACT_LIST = 'compact',\r\n\r\n  // \r\n  MODE_LIST = 'list',\r\n\r\n  // \r\n  MODE_SLIDER = 'slider',\r\n\r\n  // \r\n  MODE_DATETIME = 'datetime'\r\n}\r\n\r\n// flags for display options\r\nexport enum ParameterCtrlTypesDisplayFlag {\r\n\r\n  // \r\n  DISPLAY_CUSTOM_TITLE = 'custom_title',\r\n\r\n  // \r\n  DISPLAY_HIDE_SLIDER_SLIDER = 'hide_slider_slider',\r\n\r\n  // \r\n  DISPLAY_HIDE_SLIDER_READOUT = 'hide_slider_readout',\r\n\r\n  // \r\n  DISPLAY_HIDE_SLIDER_BUTTONS = 'hide_slider_buttons'\r\n}\r\n\r\n// The follow supports 1024 custom palettes, each with 4m shapes. Encoding is palette &lt;&lt; PaletteShift | shape.\r\nexport enum ShapeEncodeConstants {\r\n\r\n  // Shift value for palette\r\n  EncodePaletteShift = 'paletteShift',\r\n\r\n  // Mask for getting palette from encoded value. (Then shift down)\r\n  EncodePaletteMask = 'paletteMask',\r\n\r\n  // Mask for getting shape from encoded value\r\n  EncodeShapeMask = 'shapeMask'\r\n}\r\n\r\n// \r\nexport enum ShapeType {\r\n\r\n  // \r\n  ShapeCircle = 'circle',\r\n\r\n  // \r\n  ShapeSquare = 'square',\r\n\r\n  // \r\n  ShapePlus = 'plus',\r\n\r\n  // \r\n  ShapeTimes = 'times',\r\n\r\n  // \r\n  ShapeAsterisk = 'asterisk',\r\n\r\n  // \r\n  ShapeDiamond = 'diamond',\r\n\r\n  // \r\n  ShapeTriangle = 'triangle',\r\n\r\n  // \r\n  ShapeDownTriangle = 'down-triangle',\r\n\r\n  // \r\n  ShapeLeftTriangle = 'left-triangle',\r\n\r\n  // \r\n  ShapeRightTriangle = 'right-triangle',\r\n\r\n  // \r\n  MaxAllShapes = 'invalid'\r\n}\r\n\r\n// \r\nexport enum ShapePalette {\r\n\r\n  // built-in palette\r\n  ShapePaletteFilled = 'filled',\r\n\r\n  // custom palettes\r\n  ShapePaletteCustom1 = 'custom1',\r\n\r\n  // \r\n  ShapePaletteCustom2 = 'custom2',\r\n\r\n  // \r\n  ShapePaletteCustom3 = 'custom3',\r\n\r\n  // \r\n  ShapePaletteCustom4 = 'custom4',\r\n\r\n  // \r\n  ShapePaletteCustom5 = 'custom5',\r\n\r\n  // \r\n  ShapePaletteCustom6 = 'custom6',\r\n\r\n  // \r\n  ShapePaletteCustom7 = 'custom7',\r\n\r\n  // \r\n  ShapePaletteCustom8 = 'custom8',\r\n\r\n  // \r\n  ShapePaletteCustom9 = 'custom9',\r\n\r\n  // \r\n  ShapePaletteCustom10 = 'custom10',\r\n\r\n  // \r\n  ShapePaletteCustom11 = 'custom11',\r\n\r\n  // and so on...\r\n  ShapePaletteCustom12 = 'custom12',\r\n\r\n  // \r\n  ShapePaletteHidden = 'hidden'\r\n}\r\n\r\n// ShapeType and palette mapped into a single value. This enum depends on ShapeType and the implementation of ShapeManager::IntEncode.\r\nexport enum ShapeID {\r\n\r\n  // \r\n  ShapeIDCircle = 'shapeIDCircle',\r\n\r\n  // \r\n  ShapeIDSquare = 'shapeIDSquare',\r\n\r\n  // \r\n  ShapeIDPlus = 'shapeIDPlus',\r\n\r\n  // \r\n  ShapeIDTimes = 'shapeIDTimes',\r\n\r\n  // \r\n  ShapeIDAsterisk = 'shapeIDAsterisk',\r\n\r\n  // \r\n  ShapeIDDiamond = 'shapeIDDiamond',\r\n\r\n  // \r\n  ShapeIDTriangle = 'shapeIDTriangle',\r\n\r\n  // \r\n  ShapeIDDownTriangle = 'shapeIDDownTriangle',\r\n\r\n  // \r\n  ShapeIDLeftTriangle = 'shapeIDLeftTriangle',\r\n\r\n  // \r\n  ShapeIDRightTriangle = 'shapeIDRightTriangle',\r\n\r\n  // \r\n  ShapeIDFilledCircle = 'shapeIDFilledCircle',\r\n\r\n  // \r\n  ShapeIDFilledSquare = 'shapeIDFilledSquare',\r\n\r\n  // \r\n  ShapeIDFilledPlus = 'shapeIDFilledPlus',\r\n\r\n  // \r\n  ShapeIDFilledTimes = 'shapeIDFilledTimes',\r\n\r\n  // \r\n  ShapeIDFilledStar = 'shapeIDFilledStar',\r\n\r\n  // \r\n  ShapeIDFilledDiamond = 'shapeIDFilledDiamond',\r\n\r\n  // \r\n  ShapeIDFilledTriangle = 'shapeIDFilledTriangle',\r\n\r\n  // \r\n  ShapeIDFilledDownTriangle = 'shapeIDFilledDownTriangle',\r\n\r\n  // \r\n  ShapeIDFilledLeftTriangle = 'shapeIDFilledLeftTriangle',\r\n\r\n  // \r\n  ShapeIDFilledRightTriangle = 'shapeIDFilledRightTriangle',\r\n\r\n  // 0+(ShapePaletteHidden<<EncodePaletteShift)\r\n  ShapeIDUnscaledFilledCircle = 'shapeIDUnscaledFilledCircle'\r\n}\r\n\r\n// \r\nexport enum LegendTypeEnum {\r\n\r\n  // \r\n  Color = 'color',\r\n\r\n  // \r\n  Shape = 'shape',\r\n\r\n  // \r\n  Size = 'size',\r\n\r\n  // \r\n  HighlightLegend = 'highlight',\r\n\r\n  // \r\n  Map = 'map',\r\n}\r\n\r\n// \r\nexport enum BrushSpecialFields {\r\n\r\n  // \r\n  BSF_Invalid = 'invalid',\r\n\r\n  // \r\n  BSF_AllFields = 'all',\r\n\r\n  // \r\n  BSF_DatesAndTimes = 'date-time',\r\n\r\n  // \r\n  BSF_Trails = 'trails',\r\n\r\n  // \r\n  BSF_EntireTable = 'table'\r\n}\r\n\r\n// what kind of curve will be fit to the data given response variable Y and a single quantitative factor X\r\nexport enum TrendLineFitType {\r\n\r\n  // equation = Y ~ X + 1\r\n  TrendLineFitType__LinearFit = 'linear',\r\n\r\n  // equation = Y ~ X^2 + X + 1\r\n  TrendLineFitType__PolynomialFit = 'polynomial',\r\n\r\n  // equation = Y ~ log(X)\r\n  TrendLineFitType__LogFit = 'log',\r\n\r\n  // equation = Y ~ exp(X)\r\n  TrendLineFitType__ExpFit = 'exp',\r\n\r\n  // equation = Y ~ X^b\r\n  TrendLineFitType__PowerFit = 'power'\r\n}\r\n\r\n// type for components of a command presentation model\r\nexport enum CommandsEnumItemType {\r\n\r\n  // item with text and an associated command\r\n  Item = 'item',\r\n\r\n  // dynamic range of items generated by an associated command\r\n  ItemRange = 'range',\r\n\r\n  // list of subcommands\r\n  SubCommandsItem = 'subcommands',\r\n\r\n  // logical separation between groups of commands\r\n  SeparatorItem = 'separator'\r\n}\r\n\r\n// \r\nexport enum ParameterTypesDomainType {\r\n\r\n  // \r\n  Domain_Any = 'any',\r\n\r\n  // \r\n  Domain_List = 'list',\r\n\r\n  // \r\n  Domain_Range = 'range'\r\n}\r\n\r\n// Categorical filter type usage.\r\nexport enum FiltersCategoricalFilterType {\r\n\r\n  // \r\n  Visual = 'visual',\r\n\r\n  // \r\n  Extract = 'extract',\r\n\r\n  // \r\n  Group = 'group'\r\n}\r\n\r\n// Filter context domains\r\nexport enum FiltersDomainType {\r\n\r\n  // \r\n  Relevant = 'relevant',\r\n\r\n  // \r\n  Cascading = 'cascading',\r\n\r\n  // \r\n  CascadingContext = 'cascading-context',\r\n\r\n  // \r\n  Context = 'context',\r\n\r\n  // \r\n  Database = 'all'\r\n}\r\n\r\n// Selection (relational only) - Range type\r\nexport enum FiltersRangeType {\r\n\r\n  // \r\n  All = 'all',\r\n\r\n  // \r\n  Selected = 'selected',\r\n\r\n  // \r\n  Manual = 'manual'\r\n}\r\n\r\n// Pattern based filtering\r\nexport enum FiltersPatternType {\r\n\r\n  // starts with the specified pattern text\r\n  StartsWith = 'starts-with',\r\n\r\n  // ends with the specified pattern text\r\n  EndsWith = 'ends-with',\r\n\r\n  // contains the specified pattern text\r\n  Contains = 'contains',\r\n\r\n  // exactly matches the specified pattern text\r\n  ExactMatch = 'exact-match'\r\n}\r\n\r\n// \r\nexport enum FiltersLimitType {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  ByField = 'by-field',\r\n\r\n  // \r\n  Formula = 'formula'\r\n}\r\n\r\n// \r\nexport enum FiltersConditionType {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  ByField = 'by-field',\r\n\r\n  // \r\n  Formula = 'formula'\r\n}\r\n\r\n// Higher level intepretation of a relative date filter's range\r\nexport enum FiltersRelativeDateRangeType {\r\n\r\n  // \r\n  RangeCurrent = 'curr',\r\n\r\n  // \r\n  RangeCurrentToDate = 'todate',\r\n\r\n  // \r\n  RangeLast1 = 'last',\r\n\r\n  // \r\n  RangeNext1 = 'next',\r\n\r\n  // \r\n  RangeLastN = 'lastn',\r\n\r\n  // \r\n  RangeNextN = 'nextn',\r\n\r\n  // \r\n  RangeOther1 = 'other',\r\n\r\n  // \r\n  RangeOtherN = 'othern',\r\n\r\n  // \r\n  RangeInvalid = 'invalid'\r\n}\r\n\r\n// \r\nexport enum FiltersFilterMode {\r\n\r\n  // \r\n  Local = 'local',\r\n\r\n  // \r\n  Global = 'global',\r\n\r\n  // \r\n  Shared = 'shared',\r\n\r\n  // \r\n  MappedGlobal = 'mapped-global'\r\n}\r\n\r\n// How uncommitted selection state is being tracked\r\nexport enum FiltersSelectionTracking {\r\n\r\n  // Passed members have been updated: each included members' selection state should be flipped from its initial state.\r\n  DifferencesFromBase = 'differences',\r\n\r\n  // Passed members should be unconditionally selected\r\n  SelectedValues = 'selected',\r\n\r\n  // Don't save any selection state. This saves memory at the cost of not being recoverable if the controller is gone.\r\n  None = 'dont-track-selection-state'\r\n}\r\n\r\n// filter update options\r\nexport enum FilterUpdateType {\r\n\r\n  // select all values in filter\r\n  ALL = 'filter-all',\r\n\r\n  // add items to existing filter\r\n  ADD = 'filter-add',\r\n\r\n  // remove items from existing filter\r\n  REMOVE = 'filter-remove',\r\n\r\n  // replace existing filter with given options\r\n  REPLACE = 'filter-replace',\r\n\r\n  // mixture of add + removal\r\n  DELTA = 'filter-delta',\r\n\r\n  // clear the filter\r\n  CLEAR = 'filter-clear',\r\n\r\n  // each value in the filter, but individually selected\r\n  EACH = 'filter-each'\r\n}\r\n\r\n// additional context needed to perform a filter update correctly\r\nexport enum FilterUpdateQualifierType {\r\n\r\n  // the filter's domain is a manually typed in or selected subset of the full domain\r\n  CUSTOM_DOMAIN = 'filter-update-custom-domain',\r\n\r\n  // no qualifications to the filter-update are specified\r\n  NO_QUALIFICATIONS = 'filter-update-no-qual'\r\n}\r\n\r\n// \r\nexport enum FiltersPresetType {\r\n\r\n  // keep the selection chosen by the user\r\n  None = 'none',\r\n\r\n  // update to the latest values in the database\r\n  LastValues = 'last-values',\r\n\r\n  // \r\n  CurrentValues = 'current-values'\r\n}\r\n\r\n// Note: an empty range (both endpoints NULL) is defined to mean 'all non-NULL values', by symmetry with what a single-ended range means, so an empty range and InRange really means NonNull, and an empty range and nRangeOrNull really means All\r\nexport enum FiltersQuantitativeIncludedValues {\r\n\r\n  // the identity filter (everything is included)\r\n  All = 'include-all',\r\n\r\n  // all values which are non-nullptr\r\n  NonNull = 'include-non-null',\r\n\r\n  // all values which are nullptr\r\n  Null = 'include-null',\r\n\r\n  // only values within the range and which are non null\r\n  InRange = 'include-range',\r\n\r\n  // values within the range or which are nullptr\r\n  InRangeOrNull = 'include-range-or-null',\r\n\r\n  // all values are filtered out. User cannot create this type of filter directly; is only created when two filters intersect and their includedValues conflict so they will include nothing (e.g., NonNull with Null)\r\n  None = 'include-none'\r\n}\r\n\r\n// Fiscal Year Starting Month\r\nexport enum FYSValues {\r\n\r\n  // \r\n  FYSValues__FYS_JANUARY = 'fys-january',\r\n\r\n  // \r\n  FYSValues__FYS_FEBRUARY = 'fys-february',\r\n\r\n  // \r\n  FYSValues__FYS_MARCH = 'fys-march',\r\n\r\n  // \r\n  FYSValues__FYS_APRIL = 'fys-april',\r\n\r\n  // \r\n  FYSValues__FYS_MAY = 'fys-may',\r\n\r\n  // \r\n  FYSValues__FYS_JUNE = 'fys-june',\r\n\r\n  // \r\n  FYSValues__FYS_JULY = 'fys-july',\r\n\r\n  // \r\n  FYSValues__FYS_AUGUST = 'fys-august',\r\n\r\n  // \r\n  FYSValues__FYS_SEPTEMBER = 'fys-september',\r\n\r\n  // \r\n  FYSValues__FYS_OCTOBER = 'fys-october',\r\n\r\n  // \r\n  FYSValues__FYS_NOVEMBER = 'fys-november',\r\n\r\n  // \r\n  FYSValues__FYS_DECEMBER = 'fys-december'\r\n}\r\n\r\n// \r\nexport enum PageNavFlagsFlags {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  LoopedPlayback = 'looped-playback',\r\n\r\n  // \r\n  ShowDropdown = 'show-dropdown',\r\n\r\n  // \r\n  ShowSlider = 'show-slider',\r\n\r\n  // \r\n  ShowPlayCtrls = 'show-play-controls',\r\n\r\n  // \r\n  ShowTrailCtrls = 'show-trail-controls',\r\n\r\n  // \r\n  Synchronized = 'synchronized'\r\n}\r\n\r\n// \r\nexport enum PageTrailEnumsMarksToTrail {\r\n\r\n  // \r\n  Manual = 'manual',\r\n\r\n  // \r\n  All = 'all',\r\n\r\n  // \r\n  Selected = 'selected',\r\n\r\n  // \r\n  Highlighted = 'highlighted'\r\n}\r\n\r\n// \r\nexport enum PageTrailEnumsTrailType {\r\n\r\n  // \r\n  Marks = 'marks',\r\n\r\n  // \r\n  Trails = 'trails',\r\n\r\n  // \r\n  Both = 'both'\r\n}\r\n\r\n// \r\nexport enum PageTrailEnumsTrailEffect {\r\n\r\n  // \r\n  None = 'none',\r\n\r\n  // \r\n  Transparency = 'transparency'\r\n}\r\n\r\n// \r\nexport enum PageTrailEnumsTrailFlags {\r\n\r\n  // \r\n  NoFlags = 'no-flags',\r\n\r\n  // \r\n  DrawIfHighlighted = 'draw-if-highlighted',\r\n\r\n  // \r\n  DrawIfSelected = 'draw-if-selected',\r\n\r\n  // \r\n  DrawAlways = 'draw-always',\r\n\r\n  // \r\n  LinesEnabled = 'lines-enabled'\r\n}\r\n\r\n// simple page change commands\r\nexport enum ChangePageChangeType {\r\n\r\n  // \r\n  ToFirst = 'first',\r\n\r\n  // \r\n  ToNext = 'next',\r\n\r\n  // \r\n  ToPrev = 'previous',\r\n\r\n  // \r\n  ToLast = 'last'\r\n}\r\n\r\n// Stop, start in a direction, or set speed of page animation\r\nexport enum ChangePagePageAnimationControl {\r\n\r\n  // \r\n  Stop = 'stop',\r\n\r\n  // \r\n  Forward = 'forward',\r\n\r\n  // \r\n  Backward = 'backward',\r\n\r\n  // \r\n  SlowSpeed = 'slow-speed',\r\n\r\n  // \r\n  NormalSpeed = 'normal-speed',\r\n\r\n  // \r\n  FastSpeed = 'fast-speed',\r\n\r\n  // \r\n  ToggleForward = 'toggle-forward',\r\n\r\n  // \r\n  ToggleBackward = 'toggle-backward'\r\n}\r\n\r\n// \r\nexport enum LegendItemLayout {\r\n\r\n  // \r\n  LegendItemLayoutVert = 'vertical',\r\n\r\n  // \r\n  LegendItemLayoutHorz = 'horizontal',\r\n\r\n  // \r\n  LegendItemLayoutGrid = 'grid',\r\n\r\n  // \r\n  LegendItemLayoutAuto = 'auto'\r\n}\r\n\r\n// \r\nexport enum LegendItemOrder {\r\n\r\n  // \r\n  LegendItemOrderNormal = 'normal',\r\n\r\n  // \r\n  LegendItemOrderReversed = 'reversed',\r\n\r\n  // \r\n  LegendItemOrderAuto = 'auto'\r\n}\r\n\r\n// \r\nexport enum SizeMode {\r\n\r\n  // \r\n  SizeModeAuto = 'size-mode-auto',\r\n\r\n  // \r\n  SizeModeFixed = 'size-mode-fixed',\r\n\r\n  // \r\n  SizeModeMin = 'size-mode-min',\r\n\r\n  // \r\n  SizeModeMax = 'size-mode-max',\r\n\r\n  // \r\n  SizeModeRange = 'size-mode-range',\r\n\r\n  // \r\n  SizeModeFitWidth = 'size-mode-fit-width',\r\n\r\n  // \r\n  SizeModeFitHeight = 'size-mode-height',\r\n\r\n  // \r\n  SizeModeScrollHeight = 'size-mode-scroll-height'\r\n}\r\n\r\n// \r\nexport enum ShowMeCommandType {\r\n\r\n  // \r\n  SHOWME_TEXT = 'text',\r\n\r\n  // \r\n  SHOWME_HEAT = 'heat',\r\n\r\n  // \r\n  SHOWME_SPOTTABLE = 'spot-table',\r\n\r\n  // \r\n  SHOWME_BARHORIZ = 'bar-horiz',\r\n\r\n  // \r\n  SHOWME_BARSTACK = 'bar-stack',\r\n\r\n  // \r\n  SHOWME_BARSIDE = 'bar-side',\r\n\r\n  // \r\n  SHOWME_BARMEASURE = 'bar-measure',\r\n\r\n  // \r\n  SHOWME_OLINE = 'o-line',\r\n\r\n  // \r\n  SHOWME_QILINE = 'qi-line',\r\n\r\n  // \r\n  SHOWME_OAREA = 'o-area',\r\n\r\n  // \r\n  SHOWME_QIAREA = 'qi-area',\r\n\r\n  // \r\n  SHOWME_CIRCLE = 'circle',\r\n\r\n  // \r\n  SHOWME_CIRCLESIDE = 'circle-side',\r\n\r\n  // \r\n  SHOWME_GANTT = 'gantt',\r\n\r\n  // \r\n  SHOWME_SCATTER = 'scatter',\r\n\r\n  // \r\n  SHOWME_SCATTERMATRIX = 'scatter-matrix',\r\n\r\n  // \r\n  SHOWME_HISTOGRAM = 'histogram',\r\n\r\n  // \r\n  SHOWME_MAPS = 'maps',\r\n\r\n  // \r\n  SHOWME_FILLEDMAPS = 'filled-maps',\r\n\r\n  // \r\n  SHOWME_PIES = 'pies',\r\n\r\n  // \r\n  SHOWME_DUALBARLINE = 'dual-bar-line',\r\n\r\n  // \r\n  SHOWME_DUALLINE = 'dual-line',\r\n\r\n  // \r\n  SHOWME_BULLET = 'bullet',\r\n\r\n  // \r\n  SHOWME_TREEMAP = 'treemap',\r\n\r\n  // \r\n  SHOWME_BUBBLE = 'bubble',\r\n\r\n  // \r\n  SHOWME_BOXPLOT = 'box-plot',\r\n}\r\n\r\n// icon to display for an item on a shelf\r\nexport enum ShelfIconType {\r\n\r\n  // not set\r\n  SIT_None = 'none',\r\n\r\n  // incompatible field\r\n  SIT_IncompatibleField = 'incompatible-field',\r\n\r\n  // remote\r\n  SIT_Remote = 'remote',\r\n\r\n  // group\r\n  SIT_Group = 'group',\r\n\r\n  // table calc\r\n  SIT_TableCalc = 'table-calc',\r\n\r\n  // item comes from a secondary datasource\r\n  SIT_SecondaryDatasource = 'secondary-datasource',\r\n\r\n  // table calc from a secondary datasource\r\n  SIT_TableCalcSecondary = 'table-calc-secondary',\r\n\r\n  // forecast\r\n  SIT_Forecast = 'forecast',\r\n\r\n  // ascending sort\r\n  SIT_SortAsc = 'sort-asc',\r\n\r\n  // descending sort\r\n  SIT_SortDesc = 'sort-desc',\r\n\r\n  // alphabetic ascending sort\r\n  SIT_SortAlphabeticAsc = 'sort-alphabetic-asc',\r\n\r\n  // alphabetic descending sort\r\n  SIT_SortAlphabeticDesc = 'sort-alphabetic-desc'\r\n}\r\n\r\n// icon to display for an item on the filters shelf\r\nexport enum FilterIconType {\r\n\r\n  // a global filter icon\r\n  FIT_Global = 'global-filter',\r\n\r\n  // a shared filter icon\r\n  FIT_Shared = 'shared-filter',\r\n\r\n  // a mapped shared source filter icon\r\n  FIT_MappedSharedSource = 'mapped-shared-source-filter',\r\n\r\n  // a mapped shared target filter icon\r\n  FIT_MappedSharedTarget = 'mapped-shared-target-filter',\r\n\r\n  // a slicing filter icon\r\n  FIT_Slice = 'slice-filter',\r\n\r\n  // a local filter icon\r\n  FIT_Local = 'local-filter',\r\n\r\n  // a mapped global source filter icon\r\n  FIT_MappedGlobalSource = 'mapped-global-source-filter',\r\n\r\n  // a mapped global target filter icon\r\n  FIT_MappedGlobalTarget = 'mapped-global-target-filter',\r\n\r\n  // not a filter\r\n  FIT_None = 'no-filter'\r\n}\r\n\r\n// used to indicate if a field is part of a dual axis\r\nexport enum ItemDrawStyle {\r\n\r\n  // not part of a dual axis\r\n  ITEM_DRAWSTYLE_NORMAL = 'normal',\r\n\r\n  // first item on dual axis\r\n  ITEM_DRAWSTYLE_OPENED = 'opened',\r\n\r\n  // second item on dual axis\r\n  ITEM_DRAWSTYLE_CLOSED = 'closed',\r\n\r\n  // middle item in a set of layers\r\n  ITEM_DRAWSTYLE_MIDDLE = 'middle'\r\n}\r\n\r\n// indicates the size of page for a sheet\r\nexport enum PageSizeOption {\r\n\r\n  // \r\n  PAGESIZE_LETTER = 'letter',\r\n\r\n  // \r\n  PAGESIZE_LEGAL = 'legal',\r\n\r\n  // \r\n  PAGESIZE_NOTE = 'note',\r\n\r\n  // \r\n  PAGESIZE_FOLIO = 'folio',\r\n\r\n  // \r\n  PAGESIZE_TABLOID = 'tabloid',\r\n\r\n  // \r\n  PAGESIZE_LEDGER = 'ledger',\r\n\r\n  // \r\n  PAGESIZE_STATEMENT = 'statement',\r\n\r\n  // \r\n  PAGESIZE_EXECUTIVE = 'executive',\r\n\r\n  // \r\n  PAGESIZE_A3 = 'a3',\r\n\r\n  // \r\n  PAGESIZE_A4 = 'a4',\r\n\r\n  // \r\n  PAGESIZE_A5 = 'a5',\r\n\r\n  // \r\n  PAGESIZE_B4 = 'b4',\r\n\r\n  // \r\n  PAGESIZE_B5 = 'b5',\r\n\r\n  // \r\n  PAGESIZE_QUARTO = 'quarto',\r\n\r\n  // \r\n  PAGESIZE_UNSPECIFIED = 'unspecified',\r\n}\r\n\r\n// Indicates the layout of page for a sheet\r\nexport enum PageOrientation {\r\n\r\n  // \r\n  OrientationPrinter = 'printer',\r\n\r\n  // \r\n  OrientationPortrait = 'portrait',\r\n\r\n  // \r\n  OrientationLandscape = 'landscape'\r\n}\r\n\r\n// Indicates the manner of scaling of page for a sheet\r\nexport enum ScaleMode {\r\n\r\n  // \r\n  ScaleAuto = 'auto',\r\n\r\n  // \r\n  ScalePercentage = 'percent',\r\n\r\n  // \r\n  ScaleFitPages = 'fit-pages'\r\n}\r\n\r\n// Indicates the default/selectable scaling of page for a sheet\r\nexport enum PageScalingOption {\r\n\r\n  // \r\n  ScalePctAuto = 'auto',\r\n\r\n  // \r\n  ScalePct400 = 'pct400',\r\n\r\n  // \r\n  ScalePct200 = 'pct200',\r\n\r\n  // \r\n  ScalePct100 = 'pct100',\r\n\r\n  // \r\n  ScalePct90 = 'pct90',\r\n\r\n  // \r\n  ScalePct80 = 'pct80',\r\n\r\n  // \r\n  ScalePct75 = 'pct75',\r\n\r\n  // \r\n  ScalePct60 = 'pct60',\r\n\r\n  // \r\n  ScalePct50 = 'pct50',\r\n\r\n  // \r\n  ScalePct25 = 'pct25'\r\n}\r\n\r\n// \r\nexport enum SheetRange {\r\n\r\n  // \r\n  SheetRangeAll = 'all',\r\n\r\n  // \r\n  SheetRangeActive = 'active',\r\n\r\n  // \r\n  SheetRangeSelected = 'selected'\r\n}\r\n\r\n// sheet type\r\nexport enum SheetType {\r\n\r\n  // \r\n  TYPE_WORKSHEET = 'worksheet',\r\n\r\n  // \r\n  TYPE_DASHBOARD = 'dashboard',\r\n\r\n  // \r\n  TYPE_STORY = 'story'\r\n}\r\n\r\n// a dashboard image metric's type\r\nexport enum ClientUIMetricType {\r\n\r\n  // \r\n  UIMT_ScrollbarMetric = 'scrollbar-metric',\r\n\r\n  // \r\n  UIMT_QFilterFixedMetric = 'q-filter-fixed-metric',\r\n\r\n  // \r\n  UIMT_QFilterSliderMetric = 'q-filter-slider-metric',\r\n\r\n  // \r\n  UIMT_QFilterReadoutMetric = 'q-filter-readout-metric',\r\n\r\n  // \r\n  UIMT_CFilterFixedMetric = 'c-filter-fixed-metric',\r\n\r\n  // minimum check/radiolist item size\r\n  UIMT_CFilterItemMetric = 'c-filter-item-metric',\r\n\r\n  // \r\n  UIMT_HFilterFixedMetric = 'h-filter-fixed-metric',\r\n\r\n  // minimum hierarchical item size\r\n  UIMT_HFilterItemMetric = 'h-filter-item-metric',\r\n\r\n  // \r\n  UIMT_CmSliderFilterMetric = 'cm-slider-filter-metric',\r\n\r\n  // \r\n  UIMT_CmDropdownFilterMetric = 'cm-dropdown-filter-metric',\r\n\r\n  // \r\n  UIMT_CmPatternFilterMetric = 'cm-pattern-filter-metric',\r\n\r\n  // \r\n  UIMT_RDateFilterMetric = 'r-date-filter-metric',\r\n\r\n  // \r\n  UIMT_RDatePFilterMetric = 'r-date-p-filter-metric',\r\n\r\n  // \r\n  UIMT_ParamTypeInMetric = 'param-type-in-metric',\r\n\r\n  // \r\n  UIMT_ParamCompactListMetric = 'param-compact-list-metric',\r\n\r\n  // \r\n  UIMT_ParamListMetric = 'param-list-metric',\r\n\r\n  // \r\n  UIMT_ParamSliderMetric = 'param-slider-metric',\r\n\r\n  // \r\n  UIMT_ParamDateTimeMetric = 'param-date-time-metric',\r\n\r\n  // \r\n  UIMT_CFilterApplyMetric = 'c-filter-apply-metric',\r\n\r\n  // \r\n  UIMT_CmTypeInSearchMetric = 'cm-type-in-search-metric',\r\n\r\n  // minimum custom list item size\r\n  UIMT_CFilterCustomItemMetric = 'c-filter-custom-item-metric'\r\n}\r\n\r\n// a region of a viz where sort indicators may appear\r\nexport enum SortRegionType {\r\n\r\n  // \r\n  SRT_LABELS_X = 'xheader',\r\n\r\n  // \r\n  SRT_LABELS_Y = 'yheader',\r\n\r\n  // \r\n  SRT_LABELS_FIELD = 'uleft',\r\n\r\n  // \r\n  SRT_AXIS_LEFT = 'leftaxis',\r\n\r\n  // \r\n  SRT_AXIS_BOTTOM = 'bottomaxis',\r\n\r\n  // \r\n  SRT_AXIS_RIGHT = 'rightaxis',\r\n\r\n  // \r\n  SRT_AXIS_TOP = 'topaxis'\r\n}\r\n\r\n// \r\nexport enum QtCursorShape {\r\n\r\n  // \r\n  ArrowCursor = 'arrow',\r\n\r\n  // \r\n  UpArrowCursor = 'up-arrow',\r\n\r\n  // \r\n  CrossCursor = 'cross',\r\n\r\n  // \r\n  WaitCursor = 'wait',\r\n\r\n  // \r\n  IBeamCursor = 'ibeam',\r\n\r\n  // \r\n  SizeVerCursor = 'size-ver',\r\n\r\n  // \r\n  SizeHorCursor = 'size-hor',\r\n\r\n  // \r\n  SizeBDiagCursor = 'size-bdiag',\r\n\r\n  // \r\n  SizeFDiagCursor = 'size-fdiag',\r\n\r\n  // \r\n  SizeAllCursor = 'size-all',\r\n\r\n  // \r\n  BlankCursor = 'blank',\r\n\r\n  // \r\n  SplitVCursor = 'split-v',\r\n\r\n  // \r\n  SplitHCursor = 'split-h',\r\n\r\n  // \r\n  PointingHandCursor = 'pointing-hand',\r\n\r\n  // \r\n  ForbiddenCursor = 'forbidden',\r\n\r\n  // \r\n  WhatsThisCursor = 'whats-this',\r\n\r\n  // \r\n  BusyCursor = 'busy',\r\n\r\n  // \r\n  OpenHandCursor = 'open-hand',\r\n\r\n  // \r\n  ClosedHandCursor = 'closed-hand',\r\n\r\n  // \r\n  DragCopyCursor = 'drag-copy',\r\n\r\n  // \r\n  DragMoveCursor = 'drag-move',\r\n\r\n  // \r\n  DragLinkCursor = 'drag-link'\r\n}\r\n\r\n// specifies various components of a viz that are rendered as images\r\nexport enum VizImageRegion {\r\n\r\n  // the main viz area\r\n  VIZ_REGION_TABLE = 'viz',\r\n\r\n  // y axis items\r\n  VIZ_REGION_ROWHEADERS = 'yheader',\r\n\r\n  // \r\n  VIZ_REGION_LEFTAXIS = 'leftaxis',\r\n\r\n  // \r\n  VIZ_REGION_RIGHTAXIS = 'rightaxis',\r\n\r\n  // x axis items\r\n  VIZ_REGION_COLUMNHEADERS = 'xheader',\r\n\r\n  // \r\n  VIZ_REGION_BOTTOMAXIS = 'bottomaxis',\r\n\r\n  // \r\n  VIZ_REGION_TOPAXIS = 'topaxis',\r\n\r\n  // spacing areas\r\n  VIZ_REGION_UPPERLEFT = 'uleft',\r\n\r\n  // \r\n  VIZ_REGION_UPPERRIGHT = 'uright',\r\n\r\n  // \r\n  VIZ_REGION_LOWERLEFT = 'lleft',\r\n\r\n  // \r\n  VIZ_REGION_LOWERRIGHT = 'lright',\r\n\r\n  // labelling areas\r\n  VIZ_REGION_TITLE = 'title',\r\n\r\n  // \r\n  VIZ_REGION_CAPTION = 'caption',\r\n\r\n  // legend areas\r\n  VIZ_REGION_COLORLEGEND = 'color',\r\n\r\n  // \r\n  VIZ_REGION_SHAPELEGEND = 'shape',\r\n\r\n  // \r\n  VIZ_REGION_SIZELEGEND = 'size',\r\n\r\n  // \r\n  VIZ_REGION_HIGHLIGHTLEGEND = 'highlight-legend',\r\n\r\n  // \r\n  VIZ_REGION_MAPLEGEND = 'map',\r\n\r\n  // legend titles\r\n  VIZ_REGION_COLORLEGENDTITLE = 'color-title',\r\n\r\n  // \r\n  VIZ_REGION_SHAPELEGENDTITLE = 'shape-title',\r\n\r\n  // \r\n  VIZ_REGION_SIZELEGENDTITLE = 'size-title',\r\n\r\n  // \r\n  VIZ_REGION_HIGHLIGHTLEGENDTITLE = 'highlight-legend-title',\r\n\r\n  // \r\n  VIZ_REGION_MAPLEGENDTITLE = 'map-title',\r\n\r\n  // legend bodies\r\n  VIZ_REGION_COLORLEGENDBODY = 'color-body',\r\n\r\n  // \r\n  VIZ_REGION_SHAPELEGENDBODY = 'shape-body',\r\n\r\n  // \r\n  VIZ_REGION_SIZELEGENDBODY = 'size-body',\r\n\r\n  // \r\n  VIZ_REGION_HIGHLIGHTLEGENDBODY = 'highlight-legend-body',\r\n\r\n  // \r\n  VIZ_REGION_MAPLEGENDBODY = 'map-body',\r\n\r\n  // These are region names (ranges of other enums)\r\n  VIZ_REGION_END = 'end',\r\n}\r\n\r\n// names of legacy menu items\r\nexport enum LegacyMenuName {\r\n\r\n  // view underlying data\r\n  LM_NAME_VIEWDATA = 'viewdata',\r\n\r\n  // export image\r\n  LM_NAME_EXPORTIMAGE = 'exportimage',\r\n\r\n  // export data\r\n  LM_NAME_EXPORTDATA = 'exportdata',\r\n\r\n  // export as crosstab\r\n  LM_NAME_EXPORTCROSSTAB = 'exportcrosstab',\r\n\r\n  // print to pdf\r\n  LM_NAME_PRINT = 'print'\r\n}\r\n\r\n// states of legacy menu items\r\nexport enum LegacyMenuState {\r\n\r\n  // visible state\r\n  LM_STATE_VISIBLE = 'visible',\r\n\r\n  // checked state\r\n  LM_STATE_CHECKED = 'checked',\r\n\r\n  // grayed state\r\n  LM_STATE_GRAYED = 'grayed',\r\n\r\n  // radio state\r\n  LM_STATE_RADIO = 'radio',\r\n}\r\n\r\n// \r\nexport enum MemberUniquenessType {\r\n\r\n  // \r\n  UniqueWithinCube = 'cube-unique',\r\n\r\n  // \r\n  UniqueWithinHierarchy = 'hierarchy-unique',\r\n\r\n  // \r\n  UniqueWithinLevel = 'level-unique',\r\n\r\n  // \r\n  UniqueWithinParent = 'parent-unique'\r\n}\r\n\r\n// \r\nexport enum DimensionType {\r\n\r\n  // just a regular dimension, no special semantics\r\n  RegularDimension = 'regular-dimension',\r\n\r\n  // the measures dimension, which we don't model as such\r\n  MeasureDimension = 'measure-dimension',\r\n\r\n  // a time dimension\r\n  TimeDimension = 'time-dimension'\r\n}\r\n\r\n// \r\nexport enum SchemaViewerDataSourceType {\r\n\r\n  // \r\n  SVT_DS_NORMAL = 'datasource',\r\n\r\n  // \r\n  SVT_DS_NORMAL_PRIMARY = 'datasource-primary',\r\n\r\n  // \r\n  SVT_DS_NORMAL_SECONDARY = 'datasource-secondary',\r\n\r\n  // \r\n  SVT_DS_EXTRACT = 'extract',\r\n\r\n  // \r\n  SVT_DS_EXTRACT_PRIMARY = 'extract-primary',\r\n\r\n  // \r\n  SVT_DS_EXTRACT_SECONDARY = 'extract-secondary',\r\n\r\n  // \r\n  SVT_DS_CUBE = 'cube',\r\n\r\n  // \r\n  SVT_DS_CUBE_PRIMARY = 'cube-primary',\r\n\r\n  // \r\n  SVT_DS_CUBE_SECONDARY = 'cube-secondary',\r\n\r\n  // \r\n  SVT_DS_SERVER = 'server',\r\n\r\n  // \r\n  SVT_DS_SERVER_PRIMARY = 'server-primary',\r\n\r\n  // \r\n  SVT_DS_SERVER_SECONDARY = 'server-secondary'\r\n}\r\n\r\n// \r\nexport enum SchemaItemType {\r\n\r\n  // \r\n  IT_DIMENSION = 'dimension',\r\n\r\n  // \r\n  IT_HIERARCHY = 'hierarchy',\r\n\r\n  // \r\n  IT_LEVEL = 'level',\r\n\r\n  // \r\n  IT_CATEGORICAL = 'categorical',\r\n\r\n  // \r\n  IT_MEASURE = 'measure',\r\n\r\n  // \r\n  IT_VALUE = 'value',\r\n\r\n  // \r\n  IT_GROUP = 'group',\r\n\r\n  // \r\n  IT_FOLDER = 'folder',\r\n\r\n  // \r\n  IT_TABLE = 'table',\r\n\r\n  // \r\n  IT_DRILLPATH = 'drillpath',\r\n\r\n  // \r\n  IT_PARAMETER = 'parameter',\r\n\r\n  // \r\n  IT_HEADER = 'header'\r\n}\r\n\r\n// \r\nexport enum SchemaViewerFieldAllType {\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_BLANK = 'blank',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_RELATIONAL = 'relational',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_CUBE = 'cube',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_DATETIME = 'datetime',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_DATE = 'date',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_TIME = 'time',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_TEXT = 'text',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_NUMBER = 'number',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_CURRENCY = 'currency',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_BOOL = 'bool',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_HIERARCHY = 'hierarchy',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_LEVEL = 'level',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_ATTRIBUTE = 'attribute',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_FOLDER_CLOSED = 'folder-closed',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_FOLDER_OPEN = 'folder-open',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_GROUP = 'grp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_GROUP = 'invalid-grp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_SVR_GRP = 'svr-grp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_SVR_GRP = 'invalid-svr-grp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_NUMERIC_BIN_O = 'numeric-bin-o',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_NUMERIC_BIN_Q = 'numeric-bin-q',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_NUMERIC_BIN = 'invalid-numeric-bin',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_DRILLPATH = 'drillpath',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_VALID_SYSGRP = 'valid-sysgrp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_SYSGRP = 'invalid-sysgrp',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_CAT_BIN = 'cat-bin',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_CAT_BIN_GEOGAPHIC_O = 'cat-bin-geogaphic-o',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_CAT_BIN_GEOGAPHIC_Q = 'cat-bin-geogaphic-q',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_CAT_BIN = 'invalid-cat-bin',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_CAT_BIN_GEOGAPHIC_O = 'invalid-cat-bin-geogaphic-o',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_CAT_BIN_GEOGAPHIC_Q = 'invalid-cat-bin-geogaphic-q',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_GEOGRAPHIC = 'geographic',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_GEOGRAPHIC_O = 'invalid-geographic-o',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_GEOGRAPHIC_Q = 'invalid-geographic-q',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_IDENT_SET = 'ident-set',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_INVALID_IDENT_SET = 'invalid-ident-set',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_TABLE = 'table',\r\n\r\n  // \r\n  SchemaViewerFieldAllType__SVT_ALL_NONE = 'none'\r\n}\r\n\r\n// \r\nexport enum SchemaViewerFieldCubeMeasureType {\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_BLANK = 'cube-m-blank',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_FOLDER_CLOSED = 'cube-m-folder-closed',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_FOLDER_OPEN = 'cube-m-folder-open',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_DATETIME = 'cube-m-datetime',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_DATE = 'cube-m-date',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_TIME = 'cube-m-time',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_TEXT = 'cube-m-text',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_NUMBER = 'cube-m-number',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_CURRENCY = 'cube-m-currency',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_BOOLEAN = 'cube-m-boolean',\r\n\r\n  // \r\n  SchemaViewerFieldCubeMeasureType__SVT_CUBE_M_GEOGRAPHIC = 'cube-m-geographic'\r\n}\r\n\r\n// \r\nexport enum SchemaViewerFieldCubeDimensionType {\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_BLANK = 'cube-d-blank',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_HIERARCHY = 'cube-d-hierarchy',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_LEVEL = 'cube-d-level',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_HIER_CALC = 'cube-d-hier-calc',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_LVL_CALC = 'cube-d-lvl-calc',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_HIER_GEO = 'cube-d-hier-geo',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_HIER_GEO_CUSTOM = 'cube-d-hier-geo-custom',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_FOLDER_CLOSED = 'cube-d-folder-closed',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_FOLDER_OPEN = 'cube-d-folder-open',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_ATTRIBUTE = 'cube-d-attribute',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_TEXT = 'cube-d-text',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_DATETIME = 'cube-d-datetime',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_DATETIME_INVALID = 'cube-d-datetime-invalid',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_DATE = 'cube-d-date',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_DATE_INVALID = 'cube-d-date-invalid',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_GEOGRAPHIC = 'cube-d-geographic',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_GEOGRAPHIC_INVALID = 'cube-d-geographic-invalid',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_GEOGRAPHIC_CUSTOM = 'cube-d-geographic-custom',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_GEOGRAPHIC_CUSTOM_INVALID = 'cube-d-geographic-custom-invalid',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_VARYING = 'cube-d-varying',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_UDA = 'cube-d-uda',\r\n\r\n  // \r\n  SchemaViewerFieldCubeDimensionType__SVT_CUBE_D_NUMBER = 'cube-d-number'\r\n}\r\n\r\n// Indicates the selection mode: Single | Multiple.\r\nexport enum HSMSelectionMode {\r\n\r\n  // \r\n  Single = 'selection-mode-single',\r\n\r\n  // \r\n  Multiple = 'selection-mode-multiple'\r\n}\r\n\r\n// Indicates what default member to use for a hierarchical field.\r\nexport enum HSMDefaultMemberType {\r\n\r\n  // \r\n  UseDefaultMember = 'use-default-member',\r\n\r\n  // \r\n  UseAllMember = 'use-all-member',\r\n\r\n  // \r\n  UseSelectedMember = 'use-selected-member'\r\n}\r\n\r\n// Hierarchical select model presentation layer notification.\r\nexport enum HSMNotificationType {\r\n\r\n  // \r\n  Updated = 'hsm-notification-updated',\r\n\r\n  // \r\n  MissingMembers = 'hsm-notification-missing-members'\r\n}\r\n\r\n// Type of hierarchy command selection to be performed.\r\nexport enum HSMSelectionRequestType {\r\n\r\n  // \r\n  SelectMode = 'hsm-selection-request-select-mode',\r\n\r\n  // \r\n  MemberDescendantsState = 'hsm-selection-request-descendants-state',\r\n\r\n  // \r\n  SelectedMemberTuple = 'hsm-selection-request-selected-member-tuple',\r\n\r\n  // \r\n  SelectedMemberCaption = 'hsm-selection-request-selected-member-caption'\r\n}\r\n\r\n// Type of hierarchy member selection to be performed.\r\nexport enum HSMMemberSelectRequestType {\r\n\r\n  // \r\n  SelectMember = 'hsm-member-request-select-member',\r\n\r\n  // \r\n  SelectSubtree = 'hsm-member-request-select-subtree',\r\n\r\n  // \r\n  SelectLevel = 'hsm-member-request-select-level',\r\n\r\n  // \r\n  MemberSelect = 'hsm-member-request-member-select',\r\n\r\n  // \r\n  MemberLevel = 'hsm-member-request-member-level'\r\n}\r\n\r\n// Hierarchy level selection state.\r\nexport enum HSMLevelSelectionState {\r\n\r\n  // \r\n  AllSelected = 'hsm-all-selected',\r\n\r\n  // \r\n  NoneSelected = 'hsm-none-selected',\r\n\r\n  // \r\n  SomeSelected = 'hsm-some-selected',\r\n\r\n  // Used when a query is made of levels that don't exist in the given subtree. We need to distinguish that from none selected which implies that members exist but are not selected.\r\n  UnknownSelected = 'hsm-unknown-selected'\r\n}\r\n\r\n// \r\nexport enum HSMMemberLoadState {\r\n\r\n  // \r\n  AllLoaded = 'hsm-all-loaded',\r\n\r\n  // \r\n  NoneLoaded = 'hsm-none-loaded',\r\n\r\n  // \r\n  SomeLoaded = 'hsm-some-loaded'\r\n}\r\n\r\n// Return value from ConnectionStateController connect methods\r\nexport enum ConnectionAttemptResult {\r\n\r\n  // All data sources requested are connected.\r\n  CAR_Connected = 'connected',\r\n\r\n  // Not all data sources are connected.\r\n  CAR_NotConnected = 'not-connected',\r\n\r\n  // The user interrupted the connection flow to edit a connection.\r\n  CAR_UserEditConnection = 'user-edit-connection',\r\n\r\n  // The connection is not supported on the current platform.\r\n  CAR_ConnectionNotSupported = 'connection-not-supported'\r\n}\r\n\r\n// Return value from ConnectToDataServerSourceCommand::Do\r\nexport enum DataServerConnectionResult {\r\n\r\n  // The data source has been successfully added.\r\n  DSCR_Success = 'success',\r\n\r\n  // Error that was handled. There's no more to do (ex. cancel, or an exception that the command just printed to the error dialog).\r\n  DSCR_Failure = 'failure',\r\n\r\n  // Try again after making a new workbook.\r\n  DSCR_RequiresWorkbookDoc = 'requires-workbook',\r\n\r\n  // Try again after logging back on to Tableau server.\r\n  DSCR_RequiresAuthentication = 'requires-authentication',\r\n\r\n  // Try again after getting database credentials from the user. Pass them in through the DPI_DatasourceUsername and the DPI_DatasourcePassword parameters.\r\n  DSCR_RequiresDBCredentials = 'requires-db-credentials',\r\n\r\n  // Try again after associating an OAuth key from the user keychain with the data source.\r\n  DSCR_RequiresOAuthKeyAssociation = 'requires-oauth-key-association',\r\n\r\n  // The OAuth credentials used to connect to the datasource are not valid.\r\n  DSCR_RequiresValidOAuthKey = 'requires-valid-oauth-key',\r\n\r\n  // Multiple leaf connections within a federated data source contain errors (e.g., multiple leafs might need credentials).\r\n  DSCR_FederatedError = 'federated-error'\r\n}\r\n\r\n// Type of error encountered while attempting to connect.\r\nexport enum ConnectionErrorType {\r\n\r\n  // Authentication credentials are needed in order to connect.\r\n  CET_NeedsAuthentication = 'needs-authentication',\r\n\r\n  // The data source is provided by Data Server, but no Data Server connection is present.\r\n  CET_DataServerDisconnected = 'data-server-disconnected',\r\n\r\n  // An exception occurred while connecting.  This could be caused by a bad password, or wrong path/url.\r\n  CET_ExceptionWhileConnecting = 'exception-while-connecting',\r\n\r\n  // An exception occurred while trying to connect the data source as a whole.\r\n  CET_ExceptionWhileConnectingDataSource = 'exception-while-connecting-data-source',\r\n\r\n  // The connection is not supported.\r\n  CET_ConnectionNotSupported = 'connection-not-supported',\r\n\r\n  // An unexpected exception occurred.\r\n  CET_UnexpectedException = 'unexpected-exception'\r\n}\r\n\r\n// identifies the piece of the visual\r\nexport enum VisualPart {\r\n\r\n  // default bucket if type isn't specified\r\n  VP_Misc = 'misc',\r\n\r\n  // \r\n  VP_Annotations = 'annotations',\r\n\r\n  // \r\n  VP_AxisRules = 'axis-rules',\r\n\r\n  // \r\n  VP_TopAxis = 'top-axis',\r\n\r\n  // \r\n  VP_BottomAxis = 'bottom-axis',\r\n\r\n  // \r\n  VP_LeftAxis = 'left-axis',\r\n\r\n  // \r\n  VP_RightAxis = 'right-axis',\r\n\r\n  // \r\n  VP_Background = 'background',\r\n\r\n  // \r\n  VP_Borders = 'borders',\r\n\r\n  // \r\n  VP_Caption = 'caption',\r\n\r\n  // \r\n  VP_CellBorders = 'cell-borders',\r\n\r\n  // \r\n  VP_Decoration = 'decoration',\r\n\r\n  // \r\n  VP_DropLines = 'drop-lines',\r\n\r\n  // \r\n  VP_XLabels = 'x-labels',\r\n\r\n  // \r\n  VP_YLabels = 'y-labels',\r\n\r\n  // \r\n  VP_Legends = 'legends',\r\n\r\n  // \r\n  VP_Marks = 'marks',\r\n\r\n  // \r\n  VP_MarkLabels = 'mark-labels',\r\n\r\n  // \r\n  VP_MarkTrails = 'mark-trails',\r\n\r\n  // \r\n  VP_ReferenceBands = 'ref-bands',\r\n\r\n  // \r\n  VP_ReferenceLines = 'ref-lines',\r\n\r\n  // \r\n  VP_PaneBorders = 'pane-borders',\r\n\r\n  // \r\n  VP_ScrollBars = 'scroll-bars',\r\n\r\n  // \r\n  VP_Title = 'title',\r\n\r\n  // \r\n  VP_TrendLines = 'trend-lines',\r\n\r\n  // \r\n  VP_UpperMapLayers = 'upper-map-layers'\r\n}\r\n\r\n// Details of the part within an ElementId\r\nexport enum SceneModelTypesDetail {\r\n\r\n  // \r\n  NoDetail = 'no-detail',\r\n\r\n  // \r\n  MarkDetail = 'mark-detail',\r\n\r\n  // \r\n  LabelDetail = 'label-detail',\r\n\r\n  // \r\n  LabelHandleDetail = 'label-handle-detail',\r\n\r\n  // \r\n  TopLeftHandleDetail = 'top-left-handle-detail',\r\n\r\n  // \r\n  TopMidHandleDetail = 'top-mid-handle-detail',\r\n\r\n  // \r\n  TopRightHandleDetail = 'top-right-handle-detail',\r\n\r\n  // \r\n  RightMidHandleDetail = 'right-mid-handle-detail',\r\n\r\n  // \r\n  BottomRightHandleDetail = 'bottom-right-handle-detail',\r\n\r\n  // \r\n  BottomMidHandleDetail = 'bottom-mid-handle-detail',\r\n\r\n  // \r\n  BottomLeftHandleDetail = 'bottom-left-handle-detail',\r\n\r\n  // \r\n  LeftMidHandleDetail = 'left-mid-handle-detail',\r\n\r\n  // \r\n  LineDetail = 'line-detail',\r\n\r\n  // \r\n  ArrowHandleDetail = 'arrow-handle-detail',\r\n\r\n  // \r\n  TextCenterHandleDetail = 'text-center-handle-detail',\r\n\r\n  // \r\n  TextBoxHandleDetail = 'text-box-handle-detail',\r\n\r\n  // \r\n  MarkArrowHandleDetail = 'mark-arrow-handle-detail',\r\n\r\n  // \r\n  MarkMovableHandleDetail = 'mark-movable-handle-detail',\r\n\r\n  // \r\n  MarkAnchorDetail = 'mark-anchor-detail'\r\n}\r\n\r\n// \r\nexport enum SceneModelTypesHitType {\r\n\r\n  // \r\n  NoHit = 'no-hit',\r\n\r\n  // \r\n  AreaHit = 'area-hit',\r\n\r\n  // \r\n  NearHit = 'near-hit',\r\n\r\n  // \r\n  ExactHit = 'exact-hit'\r\n}\r\n\r\n// \r\nexport enum SceneModelTypesHitTestStyle {\r\n\r\n  // \r\n  BoundsTest = 'bounds-test',\r\n\r\n  // \r\n  ExactTest = 'exact-test',\r\n\r\n  // \r\n  RadialDistanceTest = 'radial-distance-test',\r\n\r\n  // \r\n  LabelTest = 'label-test'\r\n}\r\n\r\n// \r\nexport enum SceneModelTypesHitTestFlags {\r\n\r\n  // \r\n  HitTestAll = 'hit-test-all',\r\n\r\n  // \r\n  HitTestIgnoreLabels = 'hit-test-ignore-labels',\r\n\r\n  // \r\n  HitTestIgnoreAnnotations = 'hit-test-ignore-annotations',\r\n\r\n  // \r\n  HitTestForOverlay = 'hit-test-for-overlay'\r\n}\r\n\r\n// \r\nexport enum AnnotateEnum {\r\n\r\n  // \r\n  AE_Mark = 'mark',\r\n\r\n  // \r\n  AE_Point = 'point',\r\n\r\n  // \r\n  AE_Area = 'area'\r\n}\r\n\r\n// \r\nexport enum MarkEnum {\r\n\r\n  // \r\n  ME_Auto = 'auto',\r\n\r\n  // \r\n  ME_On = 'on',\r\n\r\n  // \r\n  ME_Off = 'off',\r\n\r\n  // \r\n  ME_Clear = 'clear'\r\n}\r\n\r\n// \r\nexport enum ZoomLevel {\r\n\r\n  // \r\n  ZOOM_ENTIRE_VIEW = 'zoom-entire-view',\r\n\r\n  // \r\n  ZOOM_FIT_WIDTH = 'zoom-fit-width',\r\n\r\n  // \r\n  ZOOM_FIT_HEIGHT = 'zoom-fit-height'\r\n}\r\n\r\n// \r\nexport enum ActionType {\r\n\r\n  // \r\n  AT_Unknown = 'unknown',\r\n\r\n  // \r\n  AT_Brush = 'brush',\r\n\r\n  // \r\n  AT_Filter = 'filter',\r\n\r\n  // \r\n  AT_URL = 'url'\r\n}\r\n\r\n// \r\nexport enum ShelfDropAction {\r\n\r\n  // \r\n  SdaReplace = 'replace',\r\n\r\n  // \r\n  SdaCombine = 'combine',\r\n\r\n  // \r\n  SdaInsert = 'insert',\r\n\r\n  // \r\n  SdaSwap = 'swap',\r\n\r\n  // \r\n  SdaReplaceAll = 'replace-all'\r\n}\r\n\r\n// \r\nexport enum ShelfDropContext {\r\n\r\n  // \r\n  ShelfDropContext_None = 'none',\r\n\r\n  // \r\n  ShelfDropContext_Categorical = 'categorical',\r\n\r\n  // \r\n  ShelfDropContext_Quantitative = 'quantitative'\r\n}\r\n\r\n// Drag/Drop source and target\r\nexport enum DragDropType {\r\n\r\n  // drag from or drop onto viz\r\n  DragDrop_Viz = 'drag-drop-viz',\r\n\r\n  // drag from or drop onto shelf\r\n  DragDrop_Shelf = 'drag-drop-shelf',\r\n\r\n  // drag from or drop onto schema\r\n  DragDrop_Schema = 'drag-drop-schema',\r\n\r\n  // drag from or drop onto nowhere\r\n  DragDrop_None = 'drag-drop-none',\r\n\r\n  // drag from or drop onto calculation editor\r\n  DragDrop_CalculationEditor = 'drag-drop-calculation-editor',\r\n\r\n  // drag from pivot window\r\n  DragDrop_Pivot = 'drag-drop-pivot'\r\n}\r\n\r\n// Dialog type related to redirect action required by UI\r\nexport enum CommandRedirectType {\r\n\r\n  // add new data connection dialog\r\n  CommandRedirect_AddDataConnection = 'command-redirect-add-data-connection',\r\n\r\n  // create drill path dialog\r\n  CommandRedirect_AddDrillPath = 'command-redirect-add-drill-path',\r\n\r\n  // confirmation dialog\r\n  CommandRedirect_Confirmation = 'command-redirect-confirmation',\r\n\r\n  // shows the format workbook pane\r\n  CommandRedirect_FormatWorkbook = 'command-redirect-format-workbook',\r\n\r\n  // notification dialog\r\n  CommandRedirect_Notification = 'command-redirect-notification',\r\n\r\n  // show number formatting dialog\r\n  CommandRedirect_NumberFormat = 'command-redirect-number-format',\r\n\r\n  // full-featured editor\r\n  CommandRedirect_Edit = 'command-redirect-edit',\r\n\r\n  // quick editor\r\n  CommandRedirect_QuickEdit = 'command-redirect-quick-edit',\r\n\r\n  // inline rename field\r\n  CommandRedirect_RenameField = 'command-redirect-rename-field',\r\n\r\n  // rename drill path dialog\r\n  CommandRedirect_RenameDrillPath = 'command-redirect-rename-drill-path',\r\n\r\n  // rename sheet dialog\r\n  CommandRedirect_RenameSheet = 'command-redirect-rename-sheet',\r\n\r\n  // edit web zone url\r\n  CommandRedirect_EditWebZoneUrl = 'command-redirect-edit-web-zone-url',\r\n\r\n  // edit formatting\r\n  CommandRedirect_EditFormatting = 'command-redirect-edit-formatting',\r\n\r\n  // categorical bin edit dialog\r\n  CommandRedirect_CategoricalBinEdit = 'command-redirect-categorical-bin-edit',\r\n\r\n  // numeric bin edit dialog\r\n  CommandRedirect_NumericBinEdit = 'command-redirect-numeric-bin-edit',\r\n\r\n  // rich text dialog\r\n  CommandRedirect_RichText = 'command-redirect-rich-text',\r\n\r\n  // delete sheet dialog\r\n  CommandRedirect_DeleteSheet = 'command-redirect-delete-sheet',\r\n\r\n  // No redirect required\r\n  CommandRedirect_None = 'command-redirect-none'\r\n}\r\n\r\n// Directives for heuristically interpreting user intent of command\r\nexport enum HeuristicCommandReinterpretation {\r\n\r\n  // Directs Tableau to not reinterpret specifics of the command\r\n  DoNotReinterpretCommand = 'do-not-reinterpret-command',\r\n\r\n  // Directs Tableau to guess that when the user selected all items in a filter, the intent was actually to select ALL\r\n  CategoricalFilter_InferAllWhenEverythingSelected = 'categorical-filter-infer-all-when-everything-selected'\r\n}\r\n\r\n// filter types\r\nexport enum FilterType {\r\n\r\n  // Quantitative\r\n  FLTR_Quantitative = 'Quantitative',\r\n\r\n  // Categorical\r\n  FLTR_Categorical = 'Categorical',\r\n\r\n  // Hierarchical\r\n  FLTR_Hierarchical = 'Hierarchical',\r\n\r\n  // Relative Date\r\n  FLTR_RelativeDate = 'RelativeDate',\r\n\r\n  // RelativeDatePick\r\n  FLTR_RelativeDatePick = 'RelativeDatePick',\r\n\r\n  // NotSpecified\r\n  FLTR_Default = 'FilterDefault'\r\n}\r\n\r\n// Parameter errors\r\nexport enum ParameterError {\r\n\r\n  // field aggregation is invalid\r\n  InvalidAggFields = 'invalid-agg-fields',\r\n\r\n  // field is invalid\r\n  InvalidFields = 'invalid-fields',\r\n\r\n  // filter values are invalid\r\n  InvalidFilterValues = 'invalid-filter-values',\r\n\r\n  // date value is invalid\r\n  InvalidDates = 'invalid-dates'\r\n}\r\n\r\n// \r\nexport enum SelectionType {\r\n\r\n  // \r\n  ST_Tuples = 'tuples',\r\n\r\n  // \r\n  ST_Nodes = 'nodes',\r\n\r\n  // \r\n  ST_TrendLines = 'trend-lines',\r\n\r\n  // \r\n  ST_LegendItems = 'legend-items',\r\n\r\n  // \r\n  ST_RefLines = 'ref-lines',\r\n\r\n  // \r\n  ST_Annotations = 'annotations',\r\n\r\n  // \r\n  ST_OrientedNodes = 'oriented-nodes',\r\n\r\n  // \r\n  ST_ShelfFields = 'shelf-fields'\r\n}\r\n\r\n// \r\nexport enum SelectionUpdateType {\r\n\r\n  // \r\n  SU_ADD = 'select-add',\r\n\r\n  // \r\n  SU_REMOVE = 'select-remove',\r\n\r\n  // \r\n  SU_REPLACE = 'select-replace'\r\n}\r\n\r\n// \r\nexport enum SelectOptions {\r\n\r\n  // No key down\r\n  SelectOptionsSimple = 'select-options-simple',\r\n\r\n  // Ctrl key down\r\n  SelectOptionsToggle = 'select-options-toggle',\r\n\r\n  // Shift key down\r\n  SelectOptionsRange = 'select-options-range',\r\n\r\n  // Usually triggered by right click\r\n  SelectOptionsMouseMenu = 'select-options-menu',\r\n\r\n  // An attempt to select via search\r\n  SelectOptionsSearchMatch = 'select-options-search'\r\n}\r\n\r\n// \r\nexport enum WhitespaceSelectionBehavior {\r\n\r\n  // Clear selection over whitespace based on default factors (i.e., are we in append mode?)\r\n  Default = 'default',\r\n\r\n  // Always clear selection over whitespace\r\n  AlwaysClear = 'always-clear',\r\n\r\n  // Never clear selection over whitespace\r\n  NeverClear = 'never-clear'\r\n}\r\n\r\n// \r\nexport enum Orientation {\r\n\r\n  // \r\n  Vertical = 'o-vert',\r\n\r\n  // \r\n  Horizontal = 'o-horiz',\r\n\r\n  // \r\n  OAutomatic = 'o-auto'\r\n}\r\n\r\n// \r\nexport enum ScaleType {\r\n\r\n  // \r\n  Log = 'log',\r\n\r\n  // \r\n  Linear = 'linear'\r\n}\r\n\r\n// type of object action applies to\r\nexport enum SourceType {\r\n\r\n  // all sheets in the workbook\r\n  ST_All = 'all',\r\n\r\n  // all sheets referencing a given datasource\r\n  ST_Datasource = 'datasource',\r\n\r\n  // worksheet or dashboard\r\n  ST_Sheet = 'sheet'\r\n}\r\n\r\n// how an action gets activated\r\nexport enum ActivationMethod {\r\n\r\n  // e.g. by picking an option from a context menu\r\n  AM_Explicit = 'explicitly',\r\n\r\n  // auto activated when marks are selected\r\n  AM_OnSelect = 'on-select',\r\n\r\n  // auto activated when the user moves the mouse over a mark\r\n  AM_OnHover = 'on-hover'\r\n}\r\n\r\n// whether an action should be run when selection is cleared\r\nexport enum OnClear {\r\n\r\n  // do nothing, e.g. leave filter in place\r\n  OC_Nothing = 'nothing',\r\n\r\n  // show all values\r\n  OC_ShowAll = 'show-all',\r\n\r\n  // exclude everything\r\n  OC_ExcludeAll = 'exclude-all'\r\n}\r\n\r\n// \r\nexport enum MergeOrSplit {\r\n\r\n  // \r\n  MOS_MERGE = 'merge',\r\n\r\n  // \r\n  MOS_SPLIT = 'split'\r\n}\r\n\r\n// \r\nexport enum MarkLayoutPrimitive {\r\n\r\n  // \r\n  ShapePrimitive = 'shape',\r\n\r\n  // \r\n  LinePrimitive = 'line',\r\n\r\n  // \r\n  BarPrimitive = 'bar',\r\n\r\n  // \r\n  PolarBarPrimitive = 'polar-bar',\r\n\r\n  // \r\n  TextPrimitive = 'text',\r\n\r\n  // \r\n  LabelPrimitive = 'label',\r\n\r\n  // \r\n  PiePrimitive = 'pie',\r\n\r\n  // \r\n  AreaPrimitive = 'area',\r\n\r\n  // \r\n  PolygonPrimitive = 'polygon',\r\n\r\n  // \r\n  MultipolygonPrimitive = 'multipolygon',\r\n\r\n  // \r\n  SquarePrimitive = 'square'\r\n}\r\n\r\n// Does the PaneType/PrimitiveType/LayoutType triplet result in very specific layout rules?\r\nexport enum MarkLayoutVizType {\r\n\r\n  // No special rules\r\n  Standard = 'standard',\r\n\r\n  // Generic OO Stacked rules\r\n  OOStacked = 'oo-stacked',\r\n\r\n  // OO Gantt Stacked rules\r\n  GanttStacked = 'gantt-stacked',\r\n\r\n  // Treemap\r\n  Treemap = 'treemap',\r\n\r\n  // Bubble Chart -- OO Packed circles or shapes\r\n  Bubble = 'bubble',\r\n\r\n  // Wordle\r\n  Wordle = 'wordle',\r\n\r\n  // Highlight Table\r\n  Highlight = 'highlight'\r\n}\r\n\r\n// \r\nexport enum MarkLayoutHandleSpecials {\r\n\r\n  // \r\n  CategoricalAxis = 'categorical-axis',\r\n\r\n  // \r\n  ShowSpecials = 'show-specials',\r\n\r\n  // \r\n  OmitSpecials = 'omit-specials',\r\n\r\n  // \r\n  BreakOnSpecials = 'break-on-specials'\r\n}\r\n\r\n// \r\nexport enum MarkLayoutMarkFlag {\r\n\r\n  // mark does not connect to the next mark\r\n  End = 'end',\r\n\r\n  // last mark in a multi-primitive\r\n  EndPrimitive = 'endprimitive',\r\n\r\n  // last mark has an edge connector to first mark\r\n  ClosedPrimitive = 'closedprimitive',\r\n\r\n  // visual marker should be displayed\r\n  Marked = 'marked',\r\n\r\n  // visual marker should be displayed if labelled\r\n  MarkedIfLabel = 'markediflabel',\r\n\r\n  // display debug information\r\n  Debug = 'debug',\r\n\r\n  // user flags can begin here\r\n  User = 'user'\r\n}\r\n\r\n// \r\nexport enum MarkLayoutPaneFlag {\r\n\r\n  // Allows scene to be panned in the X direction\r\n  EnablePanX = 'enable-pan-x',\r\n\r\n  // Allows scene to be panned in the Y direction\r\n  EnablePanY = 'enable-pan-y',\r\n\r\n  // Allows the positions of marks to be scaled in the X direction as the view is zoomed\r\n  EnableZoomX = 'enable-zoom-x',\r\n\r\n  // Allows the positions of marks to be scaled in the Y direction as the view is zoomed\r\n  EnableZoomY = 'enable-zoom-y',\r\n\r\n  // Allows the size of marks to be scaled in the X direction as the view is zoomed; requires width in domain coordinates\r\n  EnableScaleX = 'enable-scale-x',\r\n\r\n  // Allows the size of marks to be scaled in the Y direction as the view is zoomed; requires height in domain coordinates\r\n  EnableScaleY = 'enable-scale-y',\r\n\r\n  // Clip to cell borders in the x direction\r\n  ClipToCellX = 'clip-to-cell-x',\r\n\r\n  // Clip to cell borders in the y direction\r\n  ClipToCellY = 'clip-to-cell-y',\r\n\r\n  // Use cell clipping for selection\r\n  ClipToCellForSelection = 'clip-to-cell-for-selection',\r\n\r\n  // The x-axis is on top of pane\r\n  XAxisOnTop = 'x-axis-on-top',\r\n\r\n  // The y-axis is on the right of pane\r\n  YAxisOnRight = 'y-axis-on-right',\r\n\r\n  // The pane has cells in the x axis\r\n  HasCellsX = 'has-cells-x',\r\n\r\n  // The pane has cells in the y axis\r\n  HasCellsY = 'has-cells-y'\r\n}\r\n\r\n// \r\nexport enum MarkLayoutDropLineFlag {\r\n\r\n  // Show drop lines on selected mark\r\n  DropLineShowSelected = 'dropline-show-selected',\r\n\r\n  // Show drop lines on all marks\r\n  DropLineShowAll = 'dropline-show-all',\r\n\r\n  // Drop line to x-axis\r\n  DropLineX = 'dropline-x',\r\n\r\n  // Drop line to y-axis\r\n  DropLineY = 'dropline-y',\r\n\r\n  // Show labels on drop lines\r\n  DropLineLabels = 'dropline-labels'\r\n}\r\n\r\n// Identifies the offset for a particular table in the array of tables in PDMarksPresModel\r\nexport enum MarkLayoutDataTableID {\r\n\r\n  // The table that contains the mark information\r\n  MarkTable = 'mark-table',\r\n\r\n  // The table that contains text runs for text marks and labels\r\n  TextRunTable = 'text-run-table',\r\n\r\n  // The table that contains text styles for each text run.\r\n  TextStyleTable = 'text-style-table'\r\n}\r\n\r\n// Which labeling algorithm should be used?  Closely related to MarkLayout::VizType\r\nexport enum LabelLayoutType {\r\n\r\n  // No labels\r\n  LABEL_LAYOUT_NONE = 'unlabeled',\r\n\r\n  // Treemap - labels inside the rectangles\r\n  LABEL_LAYOUT_TREEMAP = 'treemap-labels',\r\n\r\n  // Bubble Chart - labels inside the shapes\r\n  LABEL_LAYOUT_BUBBLECHART = 'bubble-labels',\r\n\r\n  // Scatterplot - dynamic best-fit labels\r\n  LABEL_LAYOUT_SCATTERPLOT = 'scatterplot-labels',\r\n\r\n  // Standard labeling\r\n  LABEL_LAYOUT_STANDARD = 'standard-labels',\r\n\r\n  // Highlight table\r\n  LABEL_LAYOUT_HIGHLIGHT_TABLE = 'highlight-table-labels'\r\n}\r\n\r\n// MarkLayer represents the layers of a mark given the various states\r\nexport enum MarkLayer {\r\n\r\n  // \r\n  NormalUnder = 'normalUnder',\r\n\r\n  // \r\n  NormalOn = 'normalOn',\r\n\r\n  // \r\n  SelectedUnder = 'selectedUnder',\r\n\r\n  // \r\n  SelectedOn = 'selectedOn',\r\n\r\n  // \r\n  HighlightedUnder = 'highlightedUnder',\r\n\r\n  // \r\n  HighlightedOn = 'highlightedOn',\r\n\r\n  // \r\n  EdgeUnder = 'edgeUnder',\r\n\r\n  // \r\n  EdgeOn = 'edgeOn',\r\n\r\n  // \r\n  Border = 'border',\r\n\r\n  // \r\n  SelectedUnder1 = 'selectedUnder1',\r\n\r\n  // \r\n  SelectedOn1 = 'selectedOn1',\r\n\r\n  // \r\n  UnSelectedCustomShape = 'unSelectedCustomShape',\r\n\r\n  // \r\n  NormalAlphaMask = 'normalAlphaMask',\r\n\r\n  // \r\n  HaloAlphaMask = 'haloAlphaMask',\r\n\r\n  // \r\n  HighlightedUnder1 = 'highlightedUnder1',\r\n\r\n  // \r\n  HighlightedOn1 = 'highlightedOn1',\r\n\r\n  // \r\n  SelectedEdgeUnder = 'selectedEdgeUnder',\r\n\r\n  // \r\n  BlobUnder = 'blobUnder',\r\n\r\n  // \r\n  BlobOn = 'blobOn',\r\n\r\n  // \r\n  HoverOverlay = 'hoverOverlay',\r\n\r\n  // \r\n  PressedOverlay = 'pressedOverlay'\r\n}\r\n\r\n// ColorOverrideMode represents the different ways in which mark colors may be modified.\r\nexport enum ColorOverrideMode {\r\n\r\n  // \r\n  ColorOverrideNone = 'colorOverrideNone',\r\n\r\n  // \r\n  ColorOverrideFog = 'colorOverrideFog',\r\n\r\n  // \r\n  ColorOverrideOpaque = 'colorOverrideOpaque',\r\n\r\n  // \r\n  ColorOverrideReplaceAlpha = 'colorOverrideReplaceAlpha',\r\n\r\n  // \r\n  ColorOverrideCount = 'colorOverrideCount'\r\n}\r\n\r\n// ColorTransformMode represents the different ways in which mark colors may be modified.\r\nexport enum ColorTransformMode {\r\n\r\n  // \r\n  ColorTransformNone = 'colorTransformNone',\r\n\r\n  // \r\n  ColorTransformFog = 'colorTransformFog',\r\n\r\n  // \r\n  ColorTransformOpaque = 'colorTransformOpaque',\r\n\r\n  // \r\n  ColorTransformOverrideColor = 'colorTransformOverrideColor',\r\n\r\n  // \r\n  ColorTransformOverrideAlpha = 'colorTransformOverrideAlpha'\r\n}\r\n\r\n// MarkState represents valid states for a mark.\r\nexport enum MarkState {\r\n\r\n  // \r\n  MarkStateNormal = 'markStateNormal',\r\n\r\n  // \r\n  MarkStateHighlighted = 'markStateHighlighted',\r\n\r\n  // \r\n  MarkStateSelected = 'markStateSelected',\r\n\r\n  // \r\n  MarkStateInvisible = 'markStateInvisible'\r\n}\r\n\r\n// LineState represents valid states for a line multi-mark.\r\nexport enum LineState {\r\n\r\n  // \r\n  LineStateNormal = 'lineStateNormal',\r\n\r\n  // \r\n  LineStateHighlighted = 'lineStateHighlighted',\r\n\r\n  // \r\n  LineStateSelected = 'lineStateSelected'\r\n}\r\n\r\n// RenderPass represents each pass over the scene elements as each layer is rendered.\r\nexport enum RenderPass {\r\n\r\n  // \r\n  NormalUnderPass = 'normalUnderPass',\r\n\r\n  // \r\n  NormalOnPass = 'normalOnPass',\r\n\r\n  // \r\n  HighlightedUnderPass = 'highlightedUnderPass',\r\n\r\n  // \r\n  HighlightedOnPass = 'highlightedOnPass',\r\n\r\n  // \r\n  SelectedUnderPass = 'selectedUnderPass',\r\n\r\n  // \r\n  SelectedOnPass = 'selectedOnPass',\r\n\r\n  // \r\n  RenderPassCount = 'renderPassCount'\r\n}\r\n\r\n// The role associated with a scene element. This allows the draw ordering to be more efficient.\r\nexport enum ElementRole {\r\n\r\n  // \r\n  ModelContainerRole = 'modelContainerRole',\r\n\r\n  // \r\n  BackgroundRole = 'backgroundRole',\r\n\r\n  // \r\n  UnderMarkRole = 'underMarkRole',\r\n\r\n  // \r\n  MarkRole = 'markRole',\r\n\r\n  // \r\n  UnderLabelRole = 'underLabelRole',\r\n\r\n  // \r\n  LabelRole = 'labelRole',\r\n\r\n  // \r\n  ForegroundRole = 'foregroundRole'\r\n}\r\n\r\n// \r\nexport enum PathElement {\r\n\r\n  // \r\n  PathMoveTo = 'moveto',\r\n\r\n  // \r\n  PathLineTo = 'lineto',\r\n\r\n  // \r\n  PathCurveTo = 'curveto'\r\n}\r\n\r\n// The serialization is still duplicated in JsonUtils::ZoneUtils::ZoneNames and types.js\r\nexport enum ZoneType {\r\n\r\n  // \r\n  ZT_Invalid = 'invalid',\r\n\r\n  // section: name = worksheet name\r\n  ZT_Viz = 'viz',\r\n\r\n  // \r\n  ZT_ColorLegend = 'color',\r\n\r\n  // \r\n  ZT_ShapeLegend = 'shape',\r\n\r\n  // \r\n  ZT_SizeLegend = 'size',\r\n\r\n  // \r\n  ZT_MapLegend = 'map',\r\n\r\n  // param = field name\r\n  ZT_QuickFilter = 'filter',\r\n\r\n  // param = field name\r\n  ZT_Highlighter = 'highlighter',\r\n\r\n  // \r\n  ZT_CurrPage = 'current-page',\r\n\r\n  // section: name unused\r\n  ZT_Empty = 'empty',\r\n\r\n  // param = title\r\n  ZT_Title = 'title',\r\n\r\n  // param = text\r\n  ZT_Text = 'text',\r\n\r\n  // param = file name\r\n  ZT_Bitmap = 'bitmap',\r\n\r\n  // param = URL\r\n  ZT_Web = 'web',\r\n\r\n  // param = add-in id\r\n  ZT_AddIn = 'add-in',\r\n\r\n  // \r\n  ZT_Button = 'button-object',\r\n\r\n  // param = field name\r\n  ZT_ParamCtrl = 'paramctrl',\r\n\r\n  // \r\n  ZT_FlipboardNav = 'flipboard-nav',\r\n\r\n  // \r\n  ZT_Flipboard = 'flipboard',\r\n\r\n  // section: layout\r\n  ZT_LayoutBasic = 'layout-basic',\r\n\r\n  // \r\n  ZT_LayoutFlow = 'layout-flow',\r\n\r\n  // \r\n  ZT_LayoutFreeForm = 'layout-free-form',\r\n\r\n  // used only for enum iteration\r\n  ZT_End = 'end'\r\n}\r\n\r\n// \r\nexport enum ContentType {\r\n\r\n  // section: name = worksheet name\r\n  CT_Viz = 'viz',\r\n\r\n  // \r\n  CT_ColorLegend = 'color',\r\n\r\n  // \r\n  CT_ShapeLegend = 'shape',\r\n\r\n  // \r\n  CT_SizeLegend = 'size',\r\n\r\n  // \r\n  CT_MapLegend = 'map',\r\n\r\n  // param = field name\r\n  CT_QuickFilter = 'filter',\r\n\r\n  // param = field name\r\n  CT_Highlighter = 'highlighter',\r\n\r\n  // \r\n  CT_CurrPage = 'current-page',\r\n\r\n  // param = field name\r\n  CT_ParamCtrl = 'paramctrl',\r\n\r\n  // param = title\r\n  CT_Title = 'title',\r\n\r\n  // param = text\r\n  CT_Text = 'text',\r\n\r\n  // param = file name\r\n  CT_Bitmap = 'bitmap',\r\n\r\n  // param = URL\r\n  CT_Web = 'web',\r\n\r\n  // param = add-in id\r\n  CT_AddIn = 'add-in',\r\n\r\n  // \r\n  CT_Button = 'button',\r\n\r\n  // \r\n  CT_FlipboardNav = 'flipboard-nav',\r\n\r\n  // \r\n  CT_Flipboard = 'flipboard',\r\n\r\n  // Denotes that this zone has no content and therefore has a meaningful layout type\r\n  CT_None = 'content-none'\r\n}\r\n\r\n// \r\nexport enum ZoneLayoutType {\r\n\r\n  // section: layout\r\n  ZLT_Basic = 'basic',\r\n\r\n  // \r\n  ZLT_FreeForm = 'free-form',\r\n\r\n  // \r\n  ZLT_Flow = 'flow',\r\n\r\n  // \r\n  ZLT_DistributeEvenly = 'distribute-evenly',\r\n\r\n  // \r\n  ZLT_Trivial = 'trivial'\r\n}\r\n\r\n// Rectanlges in the box model\r\nexport enum BoxType {\r\n\r\n  // bounding rectangle in the box model\r\n  BT_Bounding = 'bounding',\r\n\r\n  // border rectangle in the box model excluding margins\r\n  BT_Border = 'border',\r\n\r\n  // content reactnage in the box model excluding margins plus borders and paddings\r\n  BT_Content = 'content'\r\n}\r\n\r\n// Represents the type of command to be performed on the z-order of a zone\r\nexport enum ModifyZoneZOrderCommandType {\r\n\r\n  // \r\n  ModifyZoneZOrderCommandFront = 'front',\r\n\r\n  // \r\n  ModifyZoneZOrderCommandBack = 'back',\r\n\r\n  // \r\n  ModifyZoneZOrderCommandRelativePos = 'rel-pos'\r\n}\r\n\r\n// Enumeration of valid horizontal alignments for text regions.\r\nexport enum TextRegionHAlign {\r\n\r\n  // \r\n  THA_Left = 'h-align-left',\r\n\r\n  // \r\n  THA_Center = 'h-align-center',\r\n\r\n  // \r\n  THA_Right = 'h-align-right',\r\n\r\n  // \r\n  THA_Automatic = 'h-align-auto'\r\n}\r\n\r\n// Enumeration of valid vertical alignments for text regions.\r\nexport enum TextRegionVAlign {\r\n\r\n  // \r\n  TVA_Bottom = 'v-align-bottom',\r\n\r\n  // \r\n  TVA_Center = 'v-align-center',\r\n\r\n  // \r\n  TVA_Top = 'v-align-top',\r\n\r\n  // \r\n  TVA_Automatic = 'v-align-auto'\r\n}\r\n\r\n// \r\nexport enum AutoCompleteItemType {\r\n\r\n  // \r\n  ACIT_Invalid = 'invalid',\r\n\r\n  // \r\n  ACIT_Field = 'field',\r\n\r\n  // \r\n  ACIT_Function = 'func',\r\n\r\n  // \r\n  ACIT_Separator = 'separator',\r\n\r\n  // \r\n  ACIT_Header = 'header'\r\n}\r\n\r\n// \r\nexport enum CalculationContext {\r\n\r\n  // \r\n  CC_CalculationDialog = 'calculation-dialog',\r\n\r\n  // \r\n  CC_TypeInPill = 'type-in-pill',\r\n\r\n  // \r\n  CC_FilterTop = 'filter-top',\r\n\r\n  // \r\n  CC_FilterCondition = 'filter-condition',\r\n\r\n  // \r\n  CC_JoinCalcDialog = 'join-calc-dialog'\r\n}\r\n\r\n// \r\nexport enum ForecastComponentType {\r\n\r\n  // \r\n  ForecastComponentType__ETS_NONE = 'ets-none',\r\n\r\n  // \r\n  ForecastComponentType__ETS_ADDITIVE = 'ets-additive',\r\n\r\n  // \r\n  ForecastComponentType__ETS_MULTIPLICATIVE = 'ets-multiplicative'\r\n}\r\n\r\n// \r\nexport enum PredictionIntervalAxis {\r\n\r\n  // \r\n  PI_AXIS_NONE = 'none',\r\n\r\n  // \r\n  PI_AXIS_X = 'axis-x',\r\n\r\n  // \r\n  PI_AXIS_Y = 'axis-y'\r\n}\r\n\r\n// Indicates the type of quick filter\r\nexport enum QuickFilterType {\r\n\r\n  // \r\n  QFT_Unknown = 'unknown',\r\n\r\n  // \r\n  QFT_Quantitative = 'quantitative',\r\n\r\n  // \r\n  QFT_RelativeDate = 'relative-date',\r\n\r\n  // \r\n  QFT_Hierarchy = 'hierarchy',\r\n\r\n  // \r\n  QFT_Categorical = 'categorical'\r\n}\r\n\r\n// Indicates a categorical UI control\r\nexport enum QuickFilterCategoricalCtrl {\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Readout = 'readout',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Slider = 'slider',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_StepBtns = 'step-buttons',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_AllBtn = 'all-buttons',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_FilterState = 'filterstate-button',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Search = 'search',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Domain = 'domain',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_MoreFewerButton = 'morefewer-button',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Exclude = 'exclude',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Mode = 'mode',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_Levels = 'levels',\r\n\r\n  // \r\n  QuickFilterCategoricalCtrl__QFCC_ApplyButton = 'apply-button'\r\n}\r\n\r\n// Indicates a categorical mode\r\nexport enum QuickFilterCategoricalMode {\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_CheckList = 'check-list',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_RadioList = 'radio-list',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_Dropdown = 'dropdown',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_Slider = 'slider',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_Pattern = 'pattern',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_TypeInList = 'type-in-list',\r\n\r\n  // \r\n  QuickFilterCategoricalMode__QFCM_CheckDropdown = 'check-dropdown',\r\n}\r\n\r\n// Indicates a quantitative UI control\r\nexport enum QuickFilterQuantitativeCtrl {\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_Readouts = 'readouts',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_Slider = 'slider',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_NullCtrls = 'null-controls',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_ReldatePicker = 'rel-date-picker',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_Domain = 'domain',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_MoreFewerButton = 'morefewer-button',\r\n\r\n  // \r\n  QuickFilterQuantitativeCtrl__QFQC_FilterState = 'filterstate-button'\r\n}\r\n\r\n// Indicates a quantitative mode\r\nexport enum QuickFilterQuantitativeMode {\r\n\r\n  // \r\n  QuickFilterQuantitativeMode__QFQM_MinMax = 'min-max',\r\n\r\n  // \r\n  QuickFilterQuantitativeMode__QFQM_MinOnly = 'min-only',\r\n\r\n  // \r\n  QuickFilterQuantitativeMode__QFQM_MaxOnly = 'max-only',\r\n\r\n  // \r\n  QuickFilterQuantitativeMode__QFQM_RelDate = 'rel-date',\r\n\r\n  // \r\n  QuickFilterQuantitativeMode__QFQM_RelPick = 'rel-pick'\r\n}\r\n\r\n// Where is rendering happening - client or server\r\nexport enum RenderMode {\r\n\r\n  // \r\n  RenderModeServer = 'render-mode-server',\r\n\r\n  // \r\n  RenderModeClient = 'render-mode-client'\r\n}\r\n\r\n// \r\nexport enum AddOrRemoveMarks {\r\n\r\n  // \r\n  AORM_ADD = 'add',\r\n\r\n  // \r\n  AORM_REMOVE = 'remove'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsGeoSearchVisibility {\r\n\r\n  // \r\n  GSV_On = 'on',\r\n\r\n  // \r\n  GSV_Off = 'off'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsMapScaleVisibility {\r\n\r\n  // \r\n  MSV_On = 'on',\r\n\r\n  // \r\n  MSV_Off = 'off'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsAutoDrillVisibility {\r\n\r\n  // \r\n  ADV_On = 'on',\r\n\r\n  // \r\n  ADV_Off = 'off'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsMapToolSelection {\r\n\r\n  // \r\n  MT_Pan_Map = 'pan-map',\r\n\r\n  // \r\n  MT_Rectangular_Selection = 'rectangular-selection',\r\n\r\n  // \r\n  MT_Radial_Selection = 'radial-selection',\r\n\r\n  // \r\n  MT_Zoom_In = 'zoom-in',\r\n\r\n  // \r\n  MT_Zoom_Out = 'zoom-out',\r\n\r\n  // \r\n  MT_Single_Selection = 'single-selection',\r\n\r\n  // \r\n  MT_Lasso_Selection = 'lasso-selection',\r\n\r\n  // \r\n  MT_All_Selection_Tools = 'all-selection-tools',\r\n\r\n  // \r\n  MT_Area_Zoom = 'area-zoom',\r\n\r\n  // \r\n  MT_No_Tools = 'no-tools',\r\n\r\n  // \r\n  MT_Advanced_Selection_Tools = 'advanced-selection-tools',\r\n\r\n  // \r\n  MT_Map_Tools = 'map-tools',\r\n\r\n  // \r\n  MT_Non_Map_Tools = 'non-map-tools',\r\n\r\n  // \r\n  MT_Tool_Mask = 'tool-mask'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsFloatingToolbarVisibility {\r\n\r\n  // \r\n  FTV_Auto = 'auto',\r\n\r\n  // \r\n  FTV_Show = 'show',\r\n\r\n  // \r\n  FTV_Hide = 'hide'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsVizNavigationSetting {\r\n\r\n  // \r\n  NAV_Auto = 'auto',\r\n\r\n  // \r\n  NAV_Fixed = 'fixed'\r\n}\r\n\r\n// \r\nexport enum VisualDocEnumsZoomType {\r\n\r\n  // \r\n  Percent = 'percent',\r\n\r\n  // \r\n  EntireView = 'entire-view',\r\n\r\n  // \r\n  FitWidth = 'fit-width',\r\n\r\n  // \r\n  FitHeight = 'fit-height'\r\n}\r\n\r\n// \r\nexport enum SheetScrollDirection {\r\n\r\n  // scroll-first\r\n  SheetScrollFirst = 'scroll-first',\r\n\r\n  // scroll-prev\r\n  SheetScrollPrev = 'scroll-prev',\r\n\r\n  // scroll-next\r\n  SheetScrollNext = 'scroll-next',\r\n\r\n  // scroll-last\r\n  SheetScrollLast = 'scroll-last'\r\n}\r\n\r\n// aggregation type for perspectives\r\nexport enum PerspectiveUtilsAggregateType {\r\n\r\n  // \r\n  REALITY = 'reality',\r\n\r\n  // \r\n  FIRST = 'first-time-in-cube',\r\n\r\n  // \r\n  LAST = 'latest-time-in-cube',\r\n\r\n  // \r\n  CUSTOM_FOR_CUBE = 'custom-for-cube',\r\n\r\n  // \r\n  CUSTOM_PER_ATTRIBUTE = 'custom-per-attribute'\r\n}\r\n\r\n// \r\nexport enum ZoneEdgeMove {\r\n\r\n  // \r\n  EdgeDrag = 'edge-drag',\r\n\r\n  // \r\n  EdgeSnapAlign = 'edge-snap-align',\r\n\r\n  // \r\n  EdgeSnapPosition = 'edge-snap-position'\r\n}\r\n\r\n// \r\nexport enum FormatControlType {\r\n\r\n  // \r\n  FCT_NONE = 'fct-none',\r\n\r\n  // \r\n  FCT_Color = 'fct-color',\r\n\r\n  // \r\n  FCT_Font = 'fct-font',\r\n\r\n  // \r\n  FCT_Border = 'fct-border',\r\n\r\n  // \r\n  FCT_Stroke = 'fct-stroke',\r\n\r\n  // \r\n  FCT_Number = 'fct-number',\r\n\r\n  // \r\n  FCT_Layout = 'fct-layout',\r\n\r\n  // \r\n  FCT_Text = 'fct-text',\r\n\r\n  // \r\n  FCT_OptColor = 'fct-optcolor',\r\n\r\n  // \r\n  FCT_BandColor = 'fct-bandcolor',\r\n\r\n  // \r\n  FCT_BandSize = 'fct-bandsize',\r\n\r\n  // \r\n  FCT_BandLevel = 'fct-bandlevel',\r\n\r\n  // \r\n  FCT_DivLevel = 'fct-divlevel',\r\n\r\n  // \r\n  FCT_SpecValsText = 'fct-specvalstext',\r\n\r\n  // \r\n  FCT_SpecValsGraph = 'fct-specvalsgraph',\r\n\r\n  // \r\n  FCT_HAlign = 'fct-halign',\r\n\r\n  // \r\n  FCT_Orient = 'fct-orient',\r\n\r\n  // \r\n  FCT_Rounding = 'fct-rounding',\r\n\r\n  // \r\n  FCT_LineEnd = 'fct-lineend',\r\n\r\n  // \r\n  FCT_LineEndSize = 'fct-lineendsize',\r\n\r\n  // \r\n  FCT_BodyType = 'fct-bodytype',\r\n\r\n  // \r\n  FCT_AlphaLevel = 'fct-alphalevel',\r\n\r\n  // \r\n  FCT_LineInterpolation = 'fct-line-interpolation',\r\n\r\n  // \r\n  FCT_LineMarkerPosition = 'fct-line-marker-position',\r\n\r\n  // \r\n  FCT_MarkBorder = 'fct-markborder',\r\n\r\n  // \r\n  FCT_MarkHalo = 'fct-markhalo',\r\n\r\n  // \r\n  FCT_MarkMarkers = 'fct-markmarkers',\r\n\r\n  // \r\n  FCT_RefLinePalette = 'fct-reflinepalette',\r\n\r\n  // \r\n  FCT_Reverse = 'fct-reverse',\r\n\r\n  // \r\n  FCT_Whiskers = 'fct-whiskers',\r\n\r\n  // \r\n  FCT_BoxplotPalette = 'fct-boxplotpalette',\r\n\r\n  // \r\n  FCT_SolidStroke = 'fct-solidstroke',\r\n\r\n  // \r\n  FCT_BoxplotStyle = 'fct-boxplotstyle',\r\n\r\n  // \r\n  FCT_BoxplotCompoundFill = 'fct-boxplotcompoundfill'\r\n}\r\n\r\n// \r\nexport enum FormatControlFlag {\r\n\r\n  // \r\n  FCF_VisualStylesheet = 'fcf_visualstylesheet',\r\n\r\n  // \r\n  FCF_PaneStylesheet = 'fcf_panestylesheet',\r\n\r\n  // \r\n  FCF_FixedScope = 'fcf_fixedscope',\r\n\r\n  // \r\n  FCF_AllowTransparency = 'fcf_allowtransparency'\r\n}\r\n\r\n// \r\nexport enum AppConfigEnum {\r\n\r\n  // default directory where Tableau finds data sources, logs, shapes, etc.\r\n  ACS_RepositoryDir = 'repository-dir',\r\n\r\n  // application directory\r\n  ACS_ApplicationDir = 'application-dir',\r\n\r\n  // sample workbooks directory\r\n  ACS_SamplesDir = 'samples-dir'\r\n}\r\n\r\n// \r\nexport enum DeltaType {\r\n\r\n  // \r\n  DELTA_NONE = 'none',\r\n\r\n  // \r\n  DELTA_ADDED = 'added',\r\n\r\n  // \r\n  DELTA_EDITED = 'edited',\r\n\r\n  // \r\n  DELTA_REMOVED = 'removed'\r\n}\r\n\r\n// \r\nexport enum ExtractType {\r\n\r\n  // \r\n  ExtractType_All = 'extract-type-all',\r\n\r\n  // \r\n  ExtractType_Some = 'extract-type-some',\r\n\r\n  // \r\n  ExtractType_None = 'extract-type-none'\r\n}\r\n\r\n// \r\nexport enum ExtractRefreshStatus {\r\n\r\n  // \r\n  ExtractRefresh_None = 'extract-refresh-none',\r\n\r\n  // \r\n  ExtractRefresh_Pending = 'extract-refresh-pending',\r\n\r\n  // \r\n  ExtractRefresh_InProgress = 'extract-refresh-inprogress',\r\n\r\n  // \r\n  ExtractRefresh_Done = 'extract-refresh-done',\r\n\r\n  // \r\n  ExtractRefresh_Error = 'extract-refresh-error',\r\n\r\n  // \r\n  ExtractRefresh_Canceled = 'extract-refresh-canceled'\r\n}\r\n\r\n// \r\nexport enum MapUnitSelectionEnum {\r\n\r\n  // \r\n  MUS_Automatic = 'automatic',\r\n\r\n  // \r\n  MUS_Metric = 'metric',\r\n\r\n  // \r\n  MUS_US = 'us'\r\n}\r\n\r\n// \r\nexport enum DataConnectionHistoryRefreshType {\r\n\r\n  // \r\n  RT_FULL = 'full',\r\n\r\n  // \r\n  RT_INCREMENT = 'increment',\r\n\r\n  // \r\n  RT_APPEND_FROM_DATA_SOURCE = 'append-from-data-source',\r\n\r\n  // \r\n  RT_APPEND_FROM_FILE = 'append-from-file'\r\n}\r\n\r\n// \r\nexport enum CalcStyle {\r\n\r\n  // \r\n  SCE_STYLE_DEFAULT = 'style_default',\r\n\r\n  // \r\n  SCE_STYLE_PRIMARY_FIELD = 'style_prim_field',\r\n\r\n  // \r\n  SCE_STYLE_SECONDARY_FIELD = 'style_sec_field',\r\n\r\n  // \r\n  SCE_STYLE_LOCAL_FUNCTION = 'style_local_func',\r\n\r\n  // \r\n  SCE_STYLE_REMOTE_FUNCTION = 'style_remote_func',\r\n\r\n  // \r\n  SCE_STYLE_PARAMETER = 'style_param',\r\n\r\n  // \r\n  SCE_STYLE_COMMENT = 'style_comment',\r\n\r\n  // \r\n  SCE_STYLE_INVALID_FIELD = 'style_invalid_field',\r\n\r\n  // \r\n  SCE_STYLE_TABLE_EXPR = 'style_table_expr',\r\n\r\n  // \r\n  SCE_STYLE_STRING = 'style_string',\r\n\r\n  // \r\n  SCE_STYLE_DISABLED = 'style_disabled',\r\n\r\n  // \r\n  SCE_STYLE_DRAG_OVER_FIELD = 'style_drag_over_field',\r\n\r\n  // \r\n  SCE_STYLE_DRAG_OVER_SEL = 'style_drag_over_sel',\r\n\r\n  // \r\n  SCE_STYLE_SELECTION = 'style_selection'\r\n}\r\n\r\n// \r\nexport enum FunctionGroup {\r\n\r\n  // \r\n  FG_NUMERIC = 'num',\r\n\r\n  // \r\n  FG_STRING = 'str',\r\n\r\n  // \r\n  FG_DATE = 'date',\r\n\r\n  // \r\n  FG_CAST = 'cast',\r\n\r\n  // \r\n  FG_LOGICAL = 'logic',\r\n\r\n  // \r\n  FG_AGGREGATE = 'agg',\r\n\r\n  // \r\n  FG_OPERATOR = 'oper',\r\n\r\n  // \r\n  FG_SYSTEM = 'sys',\r\n\r\n  // \r\n  FG_PASSTHRU = 'pass',\r\n\r\n  // \r\n  FG_SPECIAL = 'spec',\r\n\r\n  // \r\n  FG_USER = 'user',\r\n\r\n  // \r\n  FG_TABLECALC = 'table'\r\n}\r\n\r\n// \r\nexport enum FunctionArgType {\r\n\r\n  // \r\n  FAT_NONE = 'none',\r\n\r\n  // \r\n  FAT_BOOL = 'boolean',\r\n\r\n  // \r\n  FAT_REAL = 'real',\r\n\r\n  // \r\n  FAT_INT = 'integer',\r\n\r\n  // \r\n  FAT_STR = 'str',\r\n\r\n  // \r\n  FAT_DATETIME = 'datetime',\r\n\r\n  // \r\n  FAT_DATE = 'date',\r\n\r\n  // \r\n  FAT_LOCALSTR = 'locstr',\r\n\r\n  // \r\n  FAT_NULL = 'nil',\r\n\r\n  // \r\n  FAT_ERROR = 'err',\r\n\r\n  // \r\n  FAT_ANY = 'any',\r\n\r\n  // \r\n  FAT_BIN = 'bin',\r\n\r\n  // \r\n  FAT_TUPLE = 'tup',\r\n\r\n  // \r\n  FAT_LOCALREAL = 'locreal',\r\n\r\n  // \r\n  FAT_LOCALINT = 'locint',\r\n\r\n  // \r\n  FAT_SPATIAL = 'spatial'\r\n}\r\n\r\n// logical position of activity such as Began or Ended\r\nexport enum ActivityDisposition {\r\n\r\n  // no activity\r\n  NoDisposition = 'no-disposition',\r\n\r\n  // activity has began\r\n  Began = 'began',\r\n\r\n  // activity has ended\r\n  Ended = 'ended',\r\n\r\n  // activity has occurred but neither began nor ended is known\r\n  Occurred = 'occurred',\r\n\r\n  // indefinite activity is executing\r\n  Active = 'active',\r\n\r\n  // indefinite activity has yielded (e.g., idle, waiting, sleeping, quiesce)\r\n  Idle = 'idle'\r\n}\r\n\r\n// result of activity such as Success and Failure\r\nexport enum ActivityResult {\r\n\r\n  // activity has no result\r\n  NoResult = 'no-result',\r\n\r\n  // activity ended with success\r\n  Succeeded = 'succeeded',\r\n\r\n  // activity ended with failure\r\n  Failed = 'failure',\r\n\r\n  // activity ended with thrown exception\r\n  ThrewException = 'threw-exception',\r\n\r\n  // activity ended due to a timeout\r\n  TimedOut = 'timed-out',\r\n\r\n  // activity was canceled\r\n  Canceled = 'canceled',\r\n\r\n  // activity has unknown result\r\n  UnknownResult = 'unknown-result'\r\n}\r\n\r\n// type of analytics object\r\nexport enum AnalyticsObjectType {\r\n\r\n  // \r\n  ConstantReferenceLine = 'constant-reference-line',\r\n\r\n  // \r\n  AverageReferenceLine = 'average-reference-line',\r\n\r\n  // \r\n  CustomReferenceLine = 'custom-reference-line',\r\n\r\n  // \r\n  CustomReferenceBand = 'custom-reference-band',\r\n\r\n  // \r\n  AverageAndNinetyFive = 'average-and-ninety-five',\r\n\r\n  // \r\n  MedianAndNinetyFive = 'median-and-ninety-five',\r\n\r\n  // \r\n  CustomDistributionBand = 'custom-distribution-band',\r\n\r\n  // \r\n  Boxplot = 'boxplot',\r\n\r\n  // \r\n  CustomBoxplot = 'custom-boxplot',\r\n\r\n  // \r\n  Totals = 'totals',\r\n\r\n  // \r\n  TrendLineObject = 'trend-line-object',\r\n\r\n  // \r\n  Forecast = 'forecast',\r\n\r\n  // \r\n  Cluster = 'cluster',\r\n\r\n  // \r\n  Outlier = 'outlier',\r\n\r\n  // \r\n  MedianAndQuartiles = 'median-and-quartiles',\r\n\r\n  // \r\n  Unknown = 'unknown'\r\n}\r\n\r\n// target where an analytics object may be dropped\r\nexport enum AnalyticsObjectDropTarget {\r\n\r\n  // \r\n  TargetCell = 'target-cell',\r\n\r\n  // \r\n  TargetPane = 'target-pane',\r\n\r\n  // \r\n  TargetTable = 'target-table',\r\n\r\n  // \r\n  TargetLinear = 'target-linear',\r\n\r\n  // \r\n  TargetLog = 'target-log',\r\n\r\n  // \r\n  TargetExponential = 'target-exponential',\r\n\r\n  // \r\n  TargetPolynomial = 'target-polynomial',\r\n\r\n  // \r\n  TargetPower = 'target-power',\r\n\r\n  // \r\n  TargetForecast = 'target-forecast',\r\n\r\n  // \r\n  TargetCluster = 'target-cluster',\r\n\r\n  // \r\n  TargetOutlier = 'target-outlier',\r\n\r\n  // \r\n  TargetSubtotals = 'target-subtotals',\r\n\r\n  // \r\n  TargetColumnTotals = 'target-column-totals',\r\n\r\n  // \r\n  TargetRowTotals = 'target-row-totals'\r\n}\r\n\r\n// \r\nexport enum CalcApplyResult {\r\n\r\n  // caption for new calculation is invalid\r\n  INVALID_CAPTION = 'invalid-caption-for-new-calc',\r\n\r\n  // formula is invalid\r\n  INVALID_FORMULA = 'invalid-formula',\r\n\r\n  // successfully applied\r\n  SUCCEED = 'succeed'\r\n}\r\n\r\n// \r\nexport enum UIAutomationCommandStatus {\r\n\r\n  // \r\n  UIAutomationCommandStatus_Success = 'success',\r\n\r\n  // \r\n  UIAutomationCommandStatus_UnsupportedControlTypeError = 'unsupported-control-type-error',\r\n\r\n  // \r\n  UIAutomationCommandStatus_UnsupportedActionError = 'unsupported-action-error',\r\n\r\n  // \r\n  UIAutomationCommandStatus_ComponentNotFoundError = 'component-not-found-error',\r\n\r\n  // \r\n  UIAutomationCommandStatus_UnknownError = 'unknown-error',\r\n\r\n  // \r\n  UIAutomationCommandStatus_SaveError = 'save-error',\r\n\r\n  // \r\n  UIAutomationCommandStatus_BadInputError = 'bad-input-error'\r\n}\r\n\r\n// \r\nexport enum DropWhen {\r\n\r\n  // \r\n  DropWhenNever = 'never',\r\n\r\n  // \r\n  DropWhenAlways = 'always',\r\n\r\n  // \r\n  DropWhenSelected = 'when-selected'\r\n}\r\n\r\n// \r\nexport enum ValueDomainType {\r\n\r\n  // invalid domain\r\n  DOMAIN_INVALID = 'domain-invalid',\r\n\r\n  // user can type in any value they please\" 1\r\n  DOMAIN_FREE_ENTRY = 'domain-free-entry',\r\n\r\n  // user must select a value from the list\r\n  DOMAIN_LIST = 'domain-list',\r\n\r\n  // user can freely enter values as long as they are above min value\r\n  DOMAIN_MIN = 'domain-min',\r\n\r\n  // user can freely enter values as long as they are below max value\r\n  DOMAIN_MAX = 'domain-max'\r\n}\r\n\r\n// \r\nexport enum OperationType {\r\n\r\n  // \r\n  Equals = 'equals',\r\n\r\n  // \r\n  NotEquals = 'not-equals',\r\n\r\n  // \r\n  LessThan = 'less-than',\r\n\r\n  // \r\n  LessThanEqual = 'less-than-equal',\r\n\r\n  // \r\n  GreaterThan = 'greater-than',\r\n\r\n  // \r\n  GreaterThanEqual = 'greater-than-equal',\r\n\r\n  // \r\n  RangeInclusive = 'range-inclusive'\r\n}\r\n\r\n// \r\nexport enum DropFieldResult {\r\n\r\n  // \r\n  DropFieldNo = 'no',\r\n\r\n  // \r\n  DropFieldYes = 'yes',\r\n\r\n  // \r\n  DropFieldLock = 'lock',\r\n\r\n  // \r\n  DropFieldFilter = 'filter',\r\n\r\n  // \r\n  DropFieldDisaggregate = 'disaggregate'\r\n}\r\n\r\n// resolution type for a name conflict\r\nexport enum NameConflictResolution {\r\n\r\n  // \r\n  NRC_UseOld = 'use-old',\r\n\r\n  // \r\n  NRC_UseNew = 'use-new',\r\n\r\n  // \r\n  NRC_RenameNew = 'rename-new'\r\n}\r\n\r\n// use either a string separator or a set number of characters\r\nexport enum SeparatorType {\r\n\r\n  // \r\n  SeparatorType__StringSeparator = 'string-separator',\r\n\r\n  // \r\n  SeparatorType__CharacterCountSeparator = 'character-count-separator'\r\n}\r\n\r\n// split globally or only on the first occurrence or only on the last occurrence\r\nexport enum SplitMode {\r\n\r\n  // \r\n  SplitMode__CS_ALL = 'split-all',\r\n\r\n  // \r\n  SplitMode__CS_FIRST = 'split-first',\r\n\r\n  // \r\n  SplitMode__CS_LAST = 'split-last'\r\n}\r\n\r\n// \r\nexport enum NodeSelectionType {\r\n\r\n  // \r\n  NodeSelection_None = 'none',\r\n\r\n  // \r\n  NodeSelection_SingleRow = 'single-row',\r\n\r\n  // \r\n  NodeSelection_MultiRow = 'multi-row',\r\n\r\n  // \r\n  NodeSelection_SingleColumn = 'single-column',\r\n\r\n  // \r\n  NodeSelection_MultiColumn = 'multi-column',\r\n\r\n  // \r\n  NodeSelection_Mixed = 'mixed'\r\n}\r\n\r\n// icons for Action{Source/Dest}Combo\r\nexport enum SourceDestIcon {\r\n\r\n  // \r\n  SDI_DataSource = 'data-source',\r\n\r\n  // \r\n  SDI_Worksheet = 'worksheet',\r\n\r\n  // \r\n  SDI_Dashboard = 'dashboard',\r\n\r\n  // \r\n  SDI_All = 'all'\r\n}\r\n\r\n// position and orientation of legends on a sheet\r\nexport enum LegendLayout {\r\n\r\n  // \r\n  LL_RightVertical = 'right-vertical',\r\n\r\n  // \r\n  LL_RightHorizontal = 'right-horizontal',\r\n\r\n  // \r\n  LL_BottomVertical = 'bottom-vertical',\r\n\r\n  // \r\n  LL_BottomHorizontal = 'bottom-horizontal'\r\n}\r\n\r\n// \r\nexport enum GetJsonResponseEnum {\r\n\r\n  // the json reponse exists and is valid\r\n  JSON_OK = 'ok',\r\n\r\n  // the sheet specified is not valid\r\n  JSON_NO_SHEET = 'no-sheet',\r\n\r\n  // the field id is invalid for this filter\r\n  JSON_INVALID_FIELD = 'invalid-field'\r\n}\r\n\r\n// client metric descriptions\r\nexport enum ClientMetric {\r\n\r\n  // Unknown Metric\r\n  CM_Unknown = 'UNKNWN',\r\n\r\n  // Bootstrap Request\r\n  CM_BootstrapRequest = 'BTSTRP',\r\n\r\n  // Process Primary Payload\r\n  CM_ProcessPrimaryPayload = 'PROPRI',\r\n\r\n  // Process Secondary Payload\r\n  CM_ProcessSecondaryPayload = 'PROSEC',\r\n\r\n  // Initialize Models\r\n  CM_InitializeModels = 'MDLINI',\r\n\r\n  // Handle Model Events\r\n  CM_HandleModelEvents = 'MDLEVT',\r\n\r\n  // Execute Local Command\r\n  CM_ExecuteLocalCommand = 'EXELOC',\r\n\r\n  // Execute Remote Command\r\n  CM_ExecuteRemoteCommand = 'EXEREM',\r\n\r\n  // Process Local Command Response\r\n  CM_ProcessLocalResponse = 'PROLOC',\r\n\r\n  // Process Remote Command Response\r\n  CM_ProcessRemoteResponse = 'PROREM',\r\n\r\n  // Render Panetable\r\n  CM_RenderPanetable = 'RNDRPT',\r\n\r\n  // Render Region\r\n  CM_RenderRegion = 'RNDRRG',\r\n\r\n  // Runtime model presmodel conversion\r\n  CM_RuntimeConversion = 'RTCONV',\r\n\r\n  // Client Loaded\r\n  CM_ClientLoaded = 'CLNTLD',\r\n\r\n  // Application Startup\r\n  CM_ApplicationStartup = 'APPSTR',\r\n\r\n  // Application Interactive\r\n  CM_ApplicationInteractive = 'APPINT',\r\n\r\n  // All Zones Loaded\r\n  CM_AllZonesLoaded = 'ALLZNS',\r\n\r\n  // Toolbar Layout\r\n  CM_ToolbarLayout = 'TBRLAY',\r\n\r\n  // Toolbar HandleNewToolbar\r\n  CM_ToolbarHandleNewToolbar = 'TBRHNT',\r\n\r\n  // Toolbar AddToolbar\r\n  CM_ToolbarAddToolbar = 'TBRADD',\r\n\r\n  // Toolbar HandleResize\r\n  CM_ToolbarHandleResize = 'TBRHRE',\r\n\r\n  // JavaScript Module loaded asynchronously\r\n  CM_ModuleLoaded = 'MDLOAD'\r\n}\r\n\r\n// result code for images edit operation\r\nexport enum ImagesEditResultCode {\r\n\r\n  // \r\n  IER_Success = 'success',\r\n\r\n  // \r\n  IER_EmptyCaption = 'empty-caption',\r\n\r\n  // \r\n  IER_DuplicateCaption = 'duplicate-caption',\r\n\r\n  // \r\n  IER_FailedValidation = 'failed-validation',\r\n\r\n  // \r\n  IER_InvalidURL = 'invalid-url',\r\n\r\n  // \r\n  IER_EmptyXRange = 'empty-x-range',\r\n\r\n  // \r\n  IER_EmptyYRange = 'empty-y-range',\r\n\r\n  // \r\n  IER_NoImagePreview = 'no-image-preview',\r\n\r\n  // \r\n  IER_RenderException = 'render-exception',\r\n\r\n  // \r\n  IER_TableauException = 'tableau-exception'\r\n}\r\n\r\n// the source of the underlying data used by the data provider\r\nexport enum DataProviderType {\r\n\r\n  // \r\n  DP_Datasource = 'datasource',\r\n\r\n  // \r\n  DP_Selection = 'selection',\r\n\r\n  // \r\n  DP_Table = 'table',\r\n\r\n  // \r\n  DP_SQLQuery = 'sql-query'\r\n}\r\n\r\n// \r\nexport enum DashboardDeviceLayout {\r\n\r\n  // \r\n  DashboardDeviceLayout_Default = 'default',\r\n\r\n  // \r\n  DashboardDeviceLayout_Desktop = 'desktop',\r\n\r\n  // \r\n  DashboardDeviceLayout_Tablet = 'tablet',\r\n\r\n  // \r\n  DashboardDeviceLayout_Phone = 'phone'\r\n}\r\n\r\n// who is calling the device detection logic\r\nexport enum DeviceSource {\r\n\r\n  // Nothing special about the caller to the detection logic. This means it is the web browser.\r\n  DeviceSource_Unknown = 'unknown',\r\n\r\n  // the snapshot service for the mobile app\r\n  DeviceSource_SnapshotService = 'snapshot-srv',\r\n\r\n  // the :device url parameter\r\n  DeviceSource_UrlParam = 'url-param'\r\n}\r\n\r\n// \r\nexport enum DashboardSizingDimension {\r\n\r\n  // \r\n  NoDimension = 'no',\r\n\r\n  // \r\n  MinWidthDimension = 'minwidth',\r\n\r\n  // \r\n  MinHeightDimension = 'minheight',\r\n\r\n  // \r\n  MaxWidthDimension = 'maxwidth',\r\n\r\n  // \r\n  MaxHeightDimension = 'maxheight',\r\n\r\n  // \r\n  FixedWidthDimension = 'fixedwidth',\r\n\r\n  // \r\n  FixedHeightDimension = 'fixedheight',\r\n\r\n  // \r\n  ScrollableHeightDimension = 'scrollableheight',\r\n\r\n  // \r\n  MinDimensions = 'mins',\r\n\r\n  // \r\n  MaxDimensions = 'maxs'\r\n}\r\n\r\n// \r\nexport enum FlipboardNavType {\r\n\r\n  // \r\n  Caption = 'caption',\r\n\r\n  // \r\n  Number = 'number',\r\n\r\n  // \r\n  Dot = 'dot',\r\n\r\n  // \r\n  ArrowOnly = 'arrowonly'\r\n}\r\n\r\n// \r\nexport enum DashboardSizingMode {\r\n\r\n  // \r\n  UnspecifiedSizing = 'unspecified',\r\n\r\n  // \r\n  AutomaticSizing = 'automatic',\r\n\r\n  // \r\n  FixedSizing = 'fixed',\r\n\r\n  // \r\n  RangeSizing = 'range',\r\n\r\n  // \r\n  VScrollSizing = 'vscroll'\r\n}\r\n\r\n// \r\nexport enum GridOverlayMode {\r\n\r\n  // \r\n  GOM_Automatic = 'gom-automatic',\r\n\r\n  // \r\n  GOM_On = 'gom-on',\r\n\r\n  // \r\n  GOM_Off = 'gom-off'\r\n}\r\n\r\n// \r\nexport enum FieldPickerDialogUseCase {\r\n\r\n  // \r\n  FieldPickerDialogUseCase_ReplaceField = 'replace-field-use-case',\r\n\r\n  // \r\n  FieldPickerDialogUseCase_CreateIdentitySet = 'create-identity-set',\r\n\r\n  // \r\n  FieldPickerDialogUseCase_EditDatasrouceAliases = 'edit-datasource-aliases-use-case',\r\n\r\n  // \r\n  FieldPickerDialogUseCase_EditFilters = 'edit-filters-use-case',\r\n\r\n  // \r\n  FieldPickerDialogUseCase_ExtractFilter = 'incremental-extract-use-case'\r\n}\r\n\r\n// \r\nexport enum SideType {\r\n\r\n  // \r\n  ST_Top = 'top',\r\n\r\n  // \r\n  ST_Right = 'right',\r\n\r\n  // \r\n  ST_Bottom = 'bottom',\r\n\r\n  // \r\n  ST_Left = 'left'\r\n}\r\n\r\n// \r\nexport enum WorkgroupPublishErrorType {\r\n\r\n  // \r\n  EA_None = 'ea-none',\r\n\r\n  // \r\n  EA_Warning = 'ea-warning',\r\n\r\n  // \r\n  EA_Prompt = 'ea-prompt',\r\n\r\n  // \r\n  EA_Info = 'ea-info',\r\n\r\n  // \r\n  EA_Server = 'ea-server'\r\n}\r\n\r\n// Indicates whether the user has signed in or is signed into a server\r\nexport enum ServerConnectionStatus {\r\n\r\n  // The user has never signed in\r\n  NeverSignedIn = 'server-connection-status-never-signed-in',\r\n\r\n  // The user has signed in at least once\r\n  HasSignedIn = 'server-connection_status-has-signed-in',\r\n\r\n  // Auto sign in will be attempted\r\n  WillAutoSignIn = 'server-connection_status-will-auto-sign-in',\r\n\r\n  // The user is signed in\r\n  SignedIn = 'server-connection_status-signed-in'\r\n}\r\n\r\n// Start of Week (Starting Day)\r\nexport enum SOWValue {\r\n\r\n  // \r\n  SOWValue__SOW_SYSTEMDEFAULT = 'sow-system-default',\r\n\r\n  // \r\n  SOWValue__SOW_7DAYPERIOD = 'sow-7-day-period',\r\n\r\n  // \r\n  SOWValue__SOW_SUNDAY = 'sow-sunday',\r\n\r\n  // \r\n  SOWValue__SOW_MONDAY = 'sow-monday',\r\n\r\n  // \r\n  SOWValue__SOW_TUESDAY = 'sow-tuesday',\r\n\r\n  // \r\n  SOWValue__SOW_WEDNESDAY = 'sow-wednesday',\r\n\r\n  // \r\n  SOWValue__SOW_THURSDAY = 'sow-thursday',\r\n\r\n  // \r\n  SOWValue__SOW_FRIDAY = 'sow-friday',\r\n\r\n  // \r\n  SOWValue__SOW_SATURDAY = 'sow-saturday',\r\n\r\n  // \r\n  SOWValue__SOW_ISO8601WEEK = 'sow-iso8601-week'\r\n}\r\n\r\n// Type of Find to perform\r\nexport enum FindType {\r\n\r\n  // Starts With\r\n  FindType_Starts = 'findtype-starts',\r\n\r\n  // Ends With\r\n  FindType_Ends = 'findtype-ends',\r\n\r\n  // Contains\r\n  FindType_Contains = 'findtype-contains',\r\n\r\n  // Exact\r\n  FindType_Exact = 'findtype-exact'\r\n}\r\n\r\n// PerspectiveType of a given PerspectivePresModel\r\nexport enum PerspectiveEnumPerspectiveType {\r\n\r\n  // Reality\r\n  PerspectiveType_Reality = 'perspectivetype-reality',\r\n\r\n  // First\r\n  PerspectiveType_First = 'perspectivetype-first',\r\n\r\n  // Last\r\n  PerspectiveType_Last = 'perspectivetype-last',\r\n\r\n  // Custom\r\n  PerspectiveType_Custom = 'perspectivetype-custom'\r\n}\r\n\r\n// List of options for what to write out from get-runtime-info\r\nexport enum RuntimeInfoRuntimeOutput {\r\n\r\n  // output the VTL from the producers\r\n  RawVTL = 'raw-vtl',\r\n\r\n  // output the data store from the producers\r\n  RawStore = 'raw-store',\r\n\r\n  // output the graph and compiled VTL\r\n  PayloadVTL = 'payload-vtl',\r\n\r\n  // output the final data store after transforms are run\r\n  FinalStore = 'final-store',\r\n\r\n  // output the VTL and data store from the producers\r\n  Input = 'input',\r\n\r\n  // output the final VTL and data store after compilation and running\r\n  Output = 'output'\r\n}\r\n\r\n// \r\nexport enum GeometryType {\r\n\r\n  // \r\n  Empty = 'empty',\r\n\r\n  // \r\n  MultiPolygon = 'multiPolygon',\r\n\r\n  // \r\n  MultiPoint = 'multiPoint',\r\n\r\n  // \r\n  MultiLineString = 'multiLineString'\r\n}\r\n\r\n// \r\nexport enum MarkSizingSetting {\r\n\r\n  // \r\n  MarksScalingAutomatic = 'marks-scaling-automatic',\r\n\r\n  // \r\n  MarksScalingOn = 'marks-scaling-on',\r\n\r\n  // \r\n  MarksScalingOff = 'marks-scaling-off'\r\n}\r\n\r\n// Enumeration for card type on worksheets.\r\nexport enum CardType {\r\n\r\n  // CardManager treats zero specially, so we can't start at zero.\r\n  Columns = 'cardtype-columns',\r\n\r\n  // \r\n  Rows = 'cardtype-rows',\r\n\r\n  // \r\n  Pages = 'cardtype-pages',\r\n\r\n  // \r\n  CurrentPage = 'cardtype-currentPage',\r\n\r\n  // \r\n  Filters = 'cardtype-filters',\r\n\r\n  // \r\n  Marks = 'cardtype-marks',\r\n\r\n  // \r\n  Measures = 'cardtype-measures',\r\n\r\n  // \r\n  ColorLegend = 'cardtype-colorLegend',\r\n\r\n  // \r\n  ShapeLegend = 'cardtype-shapeLegend',\r\n\r\n  // \r\n  SizeLegend = 'cardtype-sizeLegend',\r\n\r\n  // \r\n  MapLegend = 'cardtype-mapLegend',\r\n\r\n  // \r\n  Title = 'cardtype-title',\r\n\r\n  // \r\n  Caption = 'cardtype-caption',\r\n\r\n  // \r\n  Summary = 'cardtype-summary',\r\n\r\n  // \r\n  Parameter = 'cardtype-parameter',\r\n\r\n  // \r\n  QuickFilter = 'cardtype-quickFilter',\r\n\r\n  // \r\n  Highlighter = 'cardtype-highlighter'\r\n}\r\n\r\n// Indicates the type of table data to be displayed.\r\nexport enum TableViewDataType {\r\n\r\n  // Table view with each column is specified by FieldName. DPI_Columns is required.\r\n  TableViewFieldData = 'table-view-field-data',\r\n\r\n  // Table view where the columns are defined by a group. DPI_FieldName is required.\r\n  TableViewGroupData = 'table-view-group-data'\r\n}\r\n\r\n// \r\nexport enum WarningType {\r\n\r\n  // \r\n  LINK_ERROR = 'linkerror',\r\n\r\n  // \r\n  OVERLAP_TEXT = 'WarnOverlappingText',\r\n\r\n  // \r\n  INVALID_WORKSHEET = 'WarnInvalidWorksheet',\r\n\r\n  // \r\n  OPEN_BOOK = 'openbook',\r\n\r\n  // \r\n  OPEN_DATASOURCE = 'opendatasource',\r\n\r\n  // \r\n  OPEN_SHEET = 'opensheet',\r\n\r\n  // \r\n  LOCALDATA_AMBIGUITY = 'LocalDataAmbiguity',\r\n\r\n  // \r\n  LOCALDATA_MISMATCH = 'LocalDataMismatch',\r\n\r\n  // \r\n  MISSING_LOCAL_TILE = 'MissingLocalTiles',\r\n\r\n  // \r\n  MAP_TILE_DOWNLOAD = 'MapTileDownloadError',\r\n\r\n  // \r\n  MAP_TILE_INTERMITTENT = 'MapTileIntermittent',\r\n\r\n  // \r\n  MAP_TILE_REGION = 'MapTileRegion',\r\n\r\n  // \r\n  MAP_SERVER_FORBIDDEN = 'MapServerForbidden',\r\n\r\n  // \r\n  DM_CANNOT_SCORE = 'DMCannotScore',\r\n\r\n  // \r\n  DM_SCORING_NOT_REC = 'DMScoringNotRecommended',\r\n\r\n  // \r\n  LOCAL_DATA_LIBRARY_MISSING = 'LocalDataLibraryMissing',\r\n\r\n  // \r\n  DM_MISSING_MODEL = 'DMMissingModel',\r\n\r\n  // \r\n  DI_NO_LINK = 'DINoLink',\r\n\r\n  // \r\n  LOCALDATA_NO_GEOMETRY = 'LocalDataNoGeometry',\r\n\r\n  // \r\n  LOCALDATA_NO_GEOMETRY_UPGRADE = 'LocalDataNoGeometryUpgrade',\r\n\r\n  // \r\n  DI_NO_RELATIONSHIPS = 'DINoRelationships'\r\n}\r\n\r\n// \r\nexport enum WorkbookUIMode {\r\n\r\n  // \r\n  DataTab = 'data-tab',\r\n\r\n  // \r\n  Document = 'document',\r\n\r\n  // \r\n  SheetSorter = 'sheet-sorter'\r\n}\r\n\r\n// \r\nexport enum TopLevelMenuItem {\r\n\r\n  // \r\n  File = 'file',\r\n\r\n  // \r\n  Data = 'data',\r\n\r\n  // \r\n  Worksheet = 'worksheet',\r\n\r\n  // \r\n  Dashboard = 'dashboard',\r\n\r\n  // \r\n  Analysis = 'analysis',\r\n\r\n  // \r\n  Format = 'format',\r\n\r\n  // \r\n  Map = 'map',\r\n\r\n  // \r\n  Help = 'help'\r\n}\r\n\r\n// Enumeration for different types of AddIns (Project Frelard)\r\nexport enum AddInType {\r\n\r\n  // \r\n  Invalid = 'invalid',\r\n\r\n  // \r\n  Dashboard = 'dashboard'\r\n}\r\n\r\n// Enumeration of different contexts an add-in can run in\r\nexport enum AddInContext {\r\n\r\n  // \r\n  Unknown = 'unknown',\r\n\r\n  // \r\n  Desktop = 'desktop',\r\n\r\n  // \r\n  Server = 'server'\r\n}\r\n\r\n// Enumeration of different modes an add-in can run in\r\nexport enum AddInMode {\r\n\r\n  // \r\n  Unknown = 'unknown',\r\n\r\n  // \r\n  Authoring = 'authoring',\r\n\r\n  // \r\n  Viewing = 'viewing'\r\n}\r\n\r\n// Markers for array-of-float encoding of geometry\r\nexport enum LinearFloatGeometryMarker {\r\n\r\n  // \r\n  LFG_Invalid = 'invalid',\r\n\r\n  // \r\n  LFG_MultiPolygon = 'multiPolygon',\r\n\r\n  // \r\n  LFG_MultiLine = 'multiLine',\r\n\r\n  // \r\n  LFG_MultiPoint = 'multiPoint',\r\n\r\n  // \r\n  LFG_StartObject = 'startObject',\r\n\r\n  // \r\n  LFG_StartPolygon = 'startPolygon',\r\n\r\n  // \r\n  LFG_StartLine = 'startLine',\r\n\r\n  // \r\n  LFG_EndGeometry = 'endGeometry'\r\n}\r\n\r\n// Enumeration for data alert types.\r\nexport enum DataAlertType {\r\n\r\n  // \r\n  DataPresent = 'data-present',\r\n\r\n  // \r\n  ConstComparison = 'const-comparison'\r\n}\r\n\r\n// Enumeration for valid operations in data alert conditions\r\nexport enum DataAlertConditionOperationType {\r\n\r\n  // \r\n  GreaterThan = 'greater-than',\r\n\r\n  // \r\n  GreaterThanEqual = 'greater-than-equal',\r\n\r\n  // \r\n  Equals = 'equals',\r\n\r\n  // \r\n  LessThan = 'less-than',\r\n\r\n  // \r\n  LessThanEqual = 'less-than-equal'\r\n}\r\n\r\n// Enumeration for modes the data alert dialog could be in\r\nexport enum DataAlertDialogMode {\r\n\r\n  // \r\n  Create = 'create',\r\n\r\n  // \r\n  Edit = 'edit'\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/gen-src/preslayer/Enums.ts\n **/","import { Model, ParameterId as Api, SheetPath, VersionNumber } from '@tableau/api-internal-contract';\r\n\r\nimport { ParameterId as PL } from '../../gen-src/preslayer/Params';\r\nimport { PresentationModel } from '../../gen-src/preslayer/PresModels';\r\nimport { ActiveMarksDataConverter } from './ActiveMarksDataConverter';\r\nimport { ApiToPresLayerConverter } from './ApiToPresLayerConverter';\r\nimport { FiltersConverter } from './FiltersConverter';\r\nimport { MappingRegistry } from './MappingRegistry';\r\nimport { ParametersDataConverter } from './ParametersDataConverter';\r\nimport { PresLayerToApiConverter } from './PresLayerToApiConverter';\r\nimport { UnderlyingDataConverter } from './UnderlyingDataConverter';\r\n\r\n/*tslint:disable-next-line */\r\nconst id = function(inParam: any): any { return inParam; }\r\n\r\n/**\r\n * Factory class for creating parameters mappings based on the VersionNumber of the Api\r\n *\r\n * @export\r\n * @class ParameterMappingRegistryFactory\r\n */\r\nexport class ParameterMappingRegistryFactory {\r\n  public static createPresLayerToApiParamRegistry(versionNumber: VersionNumber): PresLayerToApiMappingRegistry {\r\n    let result = new PresLayerToApiMappingRegistry();\r\n\r\n    // TODO - check the version number and construct appropriate conversions\r\n\r\n    result.addRegistration(\r\n      PL.AddInLocator,\r\n      Api.ExtensionLocator,\r\n      PresLayerToApiConverter.convertExtensionLocator);\r\n\r\n    result.addRegistration(\r\n      PL.AddInBootstrapInfo,\r\n      Api.ExtensionBootstrapInfo,\r\n      PresLayerToApiConverter.convertExtensionBootstrapInfo\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.UnderlyingDataTable,\r\n      Api.UnderlyingDataTable,\r\n      UnderlyingDataConverter.buildUnderlyingDataTable.bind(undefined, false)\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.UnderlyingDataTable,\r\n      Api.UnderlyingSummaryDataTable,\r\n      UnderlyingDataConverter.buildUnderlyingDataTable.bind(undefined, true)\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.UnderlyingDataTable,\r\n      Api.DataSourceDataTable,\r\n      UnderlyingDataConverter.buildUnderlyingDataTable.bind(undefined, true)\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.FieldCaption,\r\n      Api.FieldName,\r\n      id\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.SelectionData,\r\n      Api.SelectedData,\r\n      ActiveMarksDataConverter.buildSelectedDataTable\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.HighlightedData,\r\n      Api.HighlightedData,\r\n      ActiveMarksDataConverter.buildHighlightedDataTable\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.AddInSettingsInfo,\r\n      Api.ExtensionSettingsInfo,\r\n      PresLayerToApiConverter.convertExtensionSettingsInfo\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.Worksheet,\r\n      Api.WorksheetName,\r\n      id\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.ParameterCtrls,\r\n      Api.ParameterInfos,\r\n      ParametersDataConverter.convertParameterList\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.ParameterCtrl,\r\n      Api.ParameterInfo,\r\n      ParametersDataConverter.convertParameter\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.DataSchema,\r\n      Api.DataSchema,\r\n      PresLayerToApiConverter.convertDataSchema\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.FiltersInfo,\r\n      Api.WorksheetFilters,\r\n      FiltersConverter.convertFiltersPresModel\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.CategoricalDomain,\r\n      Api.CategoricalDomain,\r\n      FiltersConverter.convertCategoricalDomain\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.QuantitativeDomain,\r\n      Api.QuantitativeDomain,\r\n      FiltersConverter.convertQuantitativeDomain\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.JoinDescription,\r\n      Api.JoinDescription,\r\n      PresLayerToApiConverter.convertJoinDescription\r\n    );\r\n\r\n    result.addRegistration(\r\n      PL.ConnectionDescriptionSummaries,\r\n      Api.ConnectionDescriptionSummaries,\r\n      PresLayerToApiConverter.convertConnectionDescrptionSummaries\r\n    );\r\n\r\n    return result;\r\n  }\r\n\r\n  public static createApiToPresLayerParamRegistry(versionNumber: VersionNumber): ApiToPresLayerMappingRegistry {\r\n    let result = new ApiToPresLayerMappingRegistry();\r\n\r\n    // TODO - check the version number and construct appropriate conversions\r\n\r\n    result.addRegistration(Api.ExtensionLocator, PL.AddInLocator, ApiToPresLayerConverter.convertExtensionLocator);\r\n    result.addRegistration(Api.SettingsValues, PL.AddInSettings, id);\r\n    result.addRegistration(Api.IgnoreAliases, PL.IgnoreAliases, id);\r\n    result.addRegistration(Api.IgnoreSelection, PL.IgnoreSelection, id);\r\n    result.addRegistration(Api.IncludeAllColumns, PL.IncludeAllColumns, id);\r\n    result.addRegistration(Api.MaxRows, PL.MaxRows, id);\r\n    result.addRegistration(Api.VisualId, PL.VisualIDPM, ApiToPresLayerConverter.convertVisualId);\r\n    result.addRegistration(Api.ColumnsToInclude, PL.FieldDisplayNames, id);\r\n\r\n    result.addRegistration(Api.FieldName, PL.QualifiedFieldCaption, id);\r\n    result.addRegistration(Api.FilterValues, PL.FilterAliases, ApiToPresLayerConverter.convertFilterValues);\r\n    result.addRegistration(Api.FilterUpdateType, PL.FilterUpdateType, ApiToPresLayerConverter.convertFilterType);\r\n    result.addRegistration(Api.IsExcludeMode, PL.Exclude, id);\r\n    result.addRegistration(Api.FilterRangeMin, PL.RangeMin, id);\r\n    result.addRegistration(Api.FilterRangeMax, PL.RangeMax, id);\r\n    result.addRegistration(Api.FilterRangeNullOption, PL.Included, ApiToPresLayerConverter.ConvertNullOption);\r\n    result.addRegistration(Api.FieldId, PL.FieldName, id);\r\n    result.addRegistration(Api.DomainType, PL.FilterDomainType, ApiToPresLayerConverter.ConvertFilterDomainType);\r\n\r\n    result.addRegistration(Api.VisualId, PL.Worksheet, ApiToPresLayerConverter.convertVisualIdToWorksheet);\r\n    result.addRegistration(Api.VisualId, PL.Dashboard, ApiToPresLayerConverter.convertVisualIdToDashboard);\r\n\r\n    result.addRegistration(Api.ParameterCaption, PL.FieldCaption, id);\r\n    result.addRegistration(Api.ParameterFieldName, PL.FieldNameString, id);\r\n    result.addRegistration(Api.ParameterFieldName, PL.GlobalFieldName, id);\r\n    result.addRegistration(Api.ParameterValue, PL.ValueStr, id);\r\n\r\n    result.addRegistration(\r\n      Api.SheetPath,\r\n      PL.SheetPathPM,\r\n      pm => ApiToPresLayerConverter.convertSheetPath(pm as SheetPath)\r\n    );\r\n\r\n    result.addRegistration(Api.Selection, PL.Selection, id);\r\n    result.addRegistration(Api.SelectionUpdateType, PL.SelectionUpdateType, id);\r\n    result.addRegistration(Api.HierValSelectionModels, PL.HierValSelectionModels, id);\r\n    result.addRegistration(Api.QuantRangeSelectionModels, PL.QuantRangeSelectionModels, id);\r\n    result.addRegistration(Api.DimValSelectionModels, PL.DimValSelectionModels, id);\r\n\r\n    // The param PL.Datasource is the ID string for a specific datasource, not to be confused\r\n    // with the param PL.DataSource, which is the full pres model for a data source.\r\n    result.addRegistration(Api.DataSourceId, PL.Datasource, id);\r\n\r\n    return result;\r\n  }\r\n}\r\n\r\nexport class ApiToPresLayerMappingRegistry\r\n  extends MappingRegistry<Api, PL, (apiModel: Model) => PresentationModel> {}\r\n\r\nexport class PresLayerToApiMappingRegistry\r\n  extends MappingRegistry<PL, Api, (presLayerPm: PresentationModel) => Model> {}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/ParameterMappingRegistryFactory.ts\n **/","import {\r\n  DataHeader,\r\n  DataTable,\r\n  DataValue,\r\n  HighlightedMarksTable,\r\n  MarkInfo,\r\n  MarkType,\r\n  SelectedMarksTable\r\n} from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport {\r\n  DataDictionaryPresModel,\r\n  HighlightedDataPresModel,\r\n  SelectionDataPresModel,\r\n  VizDataPresModel\r\n} from '../../gen-src/preslayer/PresModels';\r\nimport { PresLayerToApiEnumMappings as EnumMapping } from './EnumMappings';\r\nimport { UnderlyingDataConverter } from './UnderlyingDataConverter';\r\n\r\n/**\r\n * Contains logic for converting the active marks on a viz into the API pres models.\r\n * In the original project, most of this was in the ProcessActiveMarks function\r\n */\r\nexport class ActiveMarksDataConverter {\r\n  private static MALFORMED_DATA: string = 'Malformed data table';\r\n  public static buildSelectedDataTable(selectedData: SelectionDataPresModel): SelectedMarksTable {\r\n    return {\r\n      data: ActiveMarksDataConverter.buildActiveMarksList(selectedData.dataDictionary, selectedData.vizData)\r\n    };\r\n  }\r\n\r\n  public static buildHighlightedDataTable(highlightedData: HighlightedDataPresModel): HighlightedMarksTable {\r\n    return {\r\n      data: ActiveMarksDataConverter.buildActiveMarksList(highlightedData.dataDictionary, highlightedData.vizData)\r\n    };\r\n  }\r\n\r\n  private static buildActiveMarksList(dataDictionary: DataDictionaryPresModel, vizData: VizDataPresModel): Array<DataTable> {\r\n    const result = new Array<DataTable>();\r\n\r\n    // The data model for the VizDataPresModel is a little strange, so this parsing takes some time to figure out.\r\n    // There can be multiple panes of data, so we must go through them one at a time to create data tables\r\n    for (let i = 0; i < vizData.paneColumnsData.paneColumnsList.length; i++) {\r\n\r\n      // Need to filter to find all the columns which are in this pane\r\n      const columns = vizData.paneColumnsData.vizDataColumns.filter(vizDataColumn => {\r\n        // We know this column matters for the current pane if this pane's index is in paneIndices\r\n        return vizDataColumn.paneIndices.indexOf(i) > -1;\r\n      });\r\n\r\n      // Create a mapping of which index in the data dictionary our columns are in\r\n      const columnIndices = columns.map(vizDataColumn => {\r\n\r\n        // The columnIndex is in the same position as the paneIndex\r\n        const paneIndex = vizDataColumn.paneIndices.indexOf(i);\r\n        const columnIndex = vizDataColumn.columnIndices[paneIndex];\r\n        return columnIndex;\r\n      });\r\n\r\n      // Get the data for the pane we are processing\r\n      const vizPane = vizData.paneColumnsData.paneColumnsList[i];\r\n\r\n      if (vizPane.vizPaneColumns.length !== columns.length) {\r\n        throw TableauException.error(ActiveMarksDataConverter.MALFORMED_DATA);\r\n      }\r\n\r\n      const headers = new Array<DataHeader>();\r\n      const rows = new Array<Array<DataValue>>();\r\n\r\n      // Column 0 will be the tuple id column. We can use this as a counter for how many rows we have\r\n      const tupleIds = vizPane.vizPaneColumns[0].tupleIds;\r\n      const marks = new Array<MarkInfo>();\r\n      for (let tupleIndex = 0; tupleIndex < tupleIds.length; tupleIndex++) {\r\n        // TODO Need to revaluate the place of this logic. If it turns out that we need a separate command\r\n        // call to get the marks info, then this logic should not be here but instead in a layer above somewhere\r\n        let mark: MarkInfo = {\r\n          type: MarkType.Bar, // hardcoding this for now\r\n          color: 'red', // hardcoding this for now\r\n          tupleId: tupleIds[tupleIndex],\r\n        };\r\n        marks.push(mark);\r\n        // We will have 1 less value in this row since there's the tupleId column\r\n        const cells = new Array<DataValue>(vizPane.vizPaneColumns.length - 1);\r\n\r\n        for (let j = 1/* skip the first which is tuple ids */; j < vizPane.vizPaneColumns.length; j++) {\r\n          // Next, we need to figure out which column we are reading data for\r\n          const column = columns[columnIndices[j]];\r\n          const vizPaneColumnData = vizPane.vizPaneColumns[j];\r\n\r\n          // Define the header when we are processing the first row\r\n          if (tupleIndex === 0) {\r\n            const header: DataHeader = {\r\n              dataType: EnumMapping.dataType.convert(column.dataType),\r\n              fieldName: column.fn,\r\n              isReferenced: true,\r\n              index: j - 1,\r\n              fieldCaption: column.fieldCaption\r\n            };\r\n\r\n            headers.push(header);\r\n          }\r\n\r\n          const value = UnderlyingDataConverter.lookupValueFromDictionary(\r\n            dataDictionary, column.dataType, vizPaneColumnData.valueIndices[tupleIndex]);\r\n\r\n          const aliasValue = UnderlyingDataConverter.lookupValueFromDictionary(\r\n            dataDictionary, column.dataType, vizPaneColumnData.aliasIndices[tupleIndex]) || '';\r\n\r\n          const formattedValue = aliasValue; // TODO - Figure out how to use the formatStrings\r\n\r\n          const dataCell: DataValue = {\r\n            value: value,\r\n            formattedValue: formattedValue,\r\n            aliasedValue: aliasValue\r\n          };\r\n\r\n          // Add our cell to this row\r\n          cells[j - 1] = dataCell;\r\n        }\r\n\r\n        rows.push(cells);\r\n      }\r\n\r\n      const dataTable: DataTable = {\r\n        dataTable: rows,\r\n        headers: headers,\r\n        marks: marks\r\n      };\r\n\r\n      result.push(dataTable);\r\n    }\r\n\r\n    return result;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/ActiveMarksDataConverter.ts\n **/","import * as Enums from '../../gen-src/preslayer/Enums';\r\nimport {\r\n  DataDictionaryPresModel,\r\n  UnderlyingDataTableColumnPresModel,\r\n  UnderlyingDataTablePresModel,\r\n  VizDataPresModel\r\n} from '../../gen-src/preslayer/PresModels';\r\nimport { PresLayerToApiEnumMappings as EnumMapping } from './EnumMappings';\r\n\r\nimport { DataHeader, DataTable, DataValue, UnderlyingDataTable } from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n/**\r\n * Contains static helper methods for converting from an underlying data pres model into the api representation.\r\n * Most of the code is a direct port from ApiUnderlyingDataHandler.cs\r\n * https://opengrok/source/xref/teams_near/workgroup/vqlweb/scriptsharp/src/UI/Api/ApiUnderlyingDataHandler.cs\r\n */\r\nexport class UnderlyingDataConverter {\r\n  public static lookupValueFromDictionary(dataDictionary: DataDictionaryPresModel, dt: Enums.DataType, index: number): string | null {\r\n    if (index < 0) {\r\n      // per cl 280396 / bugzid 81197 negative data value index means that it is special\r\n      dt = Enums.DataType.DT_STRING;\r\n      index = -index - 1;\r\n    }\r\n\r\n    let result: string | null = null;\r\n\r\n    const rawValue = UnderlyingDataConverter.getRawValue(dataDictionary, dt, index);\r\n    if (rawValue !== null) {\r\n      result = rawValue.toString();\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /* tslint:disable-next-line:no-any */\r\n  public static getRawValue(dataDictionary: DataDictionaryPresModel, dt: Enums.DataType, index: number): any {\r\n    if (!dataDictionary.dataSegments) {\r\n      return null;\r\n    }\r\n\r\n    for (const key of Object.keys(dataDictionary.dataSegments)) {\r\n      const dataSegment = dataDictionary.dataSegments[key];\r\n      for (const dataColumn of dataSegment.dataColumns) {\r\n        if (!dataColumn || dataColumn.dataType !== dt) {\r\n          continue;\r\n        }\r\n\r\n        if (index < dataColumn.dataValues.length) {\r\n          return dataColumn.dataValues[index];\r\n        }\r\n\r\n        index -= dataColumn.dataValues.length;\r\n        break;\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  public static buildDataTable(\r\n    dataDictionary: DataDictionaryPresModel, columns: Array<UnderlyingDataTableColumnPresModel>): DataTable {\r\n    const result: DataTable = {\r\n      dataTable: UnderlyingDataConverter.buildTable(dataDictionary, columns),\r\n      headers: columns.map((c, i) => UnderlyingDataConverter.buildColumnModel(c, i))\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static buildUnderlyingDataTable(isSummary: boolean, underlyingDataTable: UnderlyingDataTablePresModel): UnderlyingDataTable {\r\n    const result: UnderlyingDataTable = {\r\n      data: UnderlyingDataConverter.buildDataTable(underlyingDataTable.dataDictionary, underlyingDataTable.underlyingDataTableColumns),\r\n      isSummary: isSummary\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static buildActiveMarksTable(dataDictionary: DataDictionaryPresModel, vizData: VizDataPresModel): DataTable {\r\n    throw TableauException.apiNotImplemented(['buildActiveMarksTable']);\r\n  }\r\n\r\n  private static buildColumnModel(column: UnderlyingDataTableColumnPresModel, index: number): DataHeader {\r\n    return {\r\n      dataType: EnumMapping.dataType.convert(column.dataType),\r\n      fieldName: column.fn,\r\n      fieldCaption: column.fieldCaption,\r\n      isReferenced: !!column.isReferenced,\r\n      index: index\r\n    };\r\n  }\r\n\r\n  private static buildTable(\r\n    dataDictionary: DataDictionaryPresModel, columns: Array<UnderlyingDataTableColumnPresModel>): Array<Array<DataValue>> {\r\n\r\n    if (columns.length === 0) {\r\n      return new Array<Array<DataValue>>();\r\n    }\r\n\r\n    const rowCount = columns[0].formatValIdxs.length;\r\n    const columnCount = columns.length;\r\n\r\n    const result = new Array<Array<DataValue>>(rowCount);\r\n\r\n    // Initialize all of our rows\r\n    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {\r\n      result[rowIndex] = new Array<DataValue>(columnCount);\r\n    }\r\n\r\n    // Go through column-by-column and convert the values\r\n    for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {\r\n      const column = columns[columnIndex];\r\n      for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {\r\n        const formattedValue = UnderlyingDataConverter.lookupValueFromDictionary(\r\n            dataDictionary, Enums.DataType.DT_STRING, column.formatValIdxs[rowIndex]);\r\n\r\n        if (formattedValue === null) {\r\n          throw TableauException.isNull(['formattedValue']);\r\n        }\r\n\r\n        const value: DataValue = {\r\n          value: UnderlyingDataConverter.lookupValueFromDictionary(\r\n            dataDictionary, column.dataType, column.valueIndices[rowIndex]),\r\n          formattedValue: formattedValue,\r\n          aliasedValue: formattedValue\r\n        };\r\n\r\n        result[rowIndex][columnIndex] = value;\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/UnderlyingDataConverter.ts\n **/","import * as Api from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\nimport * as PresLayer from '../../gen-src/preslayer/PresModels';\r\nimport { ApiToPresLayerEnumMappings as EnumConverter } from './EnumMappings';\r\n\r\n/**\r\n * Class containing helper methods for converting from ApiPresModels to their PresLayer equivalents\r\n *\r\n * @export\r\n * @class ApiToPresLayerConverter\r\n */\r\nexport class ApiToPresLayerConverter {\r\n  public static convertSheetPath(apiSheetPath?: Api.SheetPath): PresLayer.SheetPathPresModel {\r\n    if (!apiSheetPath) {\r\n      throw TableauException.isUndefined(['sheetPath']);\r\n    }\r\n\r\n    const result: PresLayer.SheetPathPresModel = {\r\n      sheetName: apiSheetPath.sheetName,\r\n      isDashboard: apiSheetPath.isDashboard,\r\n      storyboard: apiSheetPath.storyboard || '',\r\n      flipboardZoneId: apiSheetPath.flipboardZoneID || 0,\r\n      storyPointId: apiSheetPath.storyPointID || 0,\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertExtensionLocator(apiExtensionLocator: Api.ExtensionLocator): PresLayer.AddInLocatorPresModel {\r\n    const result: PresLayer.AddInLocatorPresModel = {\r\n      addInInstanceId: apiExtensionLocator.instanceId,\r\n      sheetPath: ApiToPresLayerConverter.convertSheetPath(apiExtensionLocator.dashboardPath)\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  public static convertVisualId(apiVisualid: Api.VisualId): PresLayer.VisualIDPresModel {\r\n    const result = {\r\n      worksheet: apiVisualid.worksheet,\r\n      dashboard: apiVisualid.dashboard,\r\n      storyboard: apiVisualid.storyboard,\r\n      storyPointId: apiVisualid.storyPointID,\r\n      flipboardZoneId: apiVisualid.flipboardZoneID\r\n    };\r\n\r\n    return result as PresLayer.VisualIDPresModel;\r\n  }\r\n\r\n  public static convertVisualIdToWorksheet(apiVisualId: Api.VisualId): string {\r\n    return apiVisualId.worksheet;\r\n  }\r\n\r\n  public static convertVisualIdToDashboard(apiVisualId: Api.VisualId): string {\r\n    return apiVisualId.dashboard || '';\r\n  }\r\n\r\n  public static convertFilterValues(filterValues: Array<string>): Array<string> {\r\n    if (filterValues.length === 0) {\r\n      // platform code expects an empty string for clearing filter values\r\n      return [''];\r\n    }\r\n    return filterValues;\r\n  }\r\n\r\n  public static convertFilterType(filterUpdateType: Api.FilterUpdateType): string {\r\n    return EnumConverter.filterUpdateType.convert(filterUpdateType);\r\n  }\r\n\r\n  public static ConvertNullOption(nullOption: Api.FilterNullOption): string {\r\n    return EnumConverter.nullOption.convert(nullOption);\r\n  }\r\n\r\n  public static ConvertFilterDomainType(filterDomainType: Api.FilterDomainType): string {\r\n    return EnumConverter.filterDomainType.convert(filterDomainType);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/ApiToPresLayerConverter.ts\n **/","import {\r\n  CategoricalDomain,\r\n  CategoricalFilter,\r\n  DataValue,\r\n  Filter,\r\n  FilterType,\r\n  RangeDomain,\r\n  RangeFilter,\r\n  RelativeDateFilter,\r\n} from '@tableau/api-internal-contract';\r\n\r\nimport {\r\n  DataType,\r\n  FiltersQuantitativeIncludedValues as IncludedValues,\r\n  FilterType as PresLayerFilterType,\r\n} from '../../gen-src/preslayer/Enums';\r\n\r\nimport {\r\n  CategoricalDomainPresModel,\r\n  FilterInfoPresModel,\r\n  FilterValuePresModel,\r\n  QuantitativeDomainPresModel,\r\n} from '../../gen-src/preslayer/PresModels';\r\n\r\nimport { PresLayerToApiEnumMappings as EnumMappings } from './EnumMappings';\r\nimport { PresLayerToApiConverter } from './PresLayerToApiConverter';\r\n\r\nexport class FiltersConverter {\r\n  public static convertFiltersPresModel(filterPms: FilterInfoPresModel[]): Filter[] {\r\n    let filters: Filter[] = [];\r\n    filterPms.forEach( filterPm => {\r\n      switch (filterPm.filterType) {\r\n        case PresLayerFilterType.FLTR_Categorical: {\r\n          filters.push(FiltersConverter.convertCategoricalFilterPresModel(filterPm));\r\n          break;\r\n        }\r\n\r\n        case PresLayerFilterType.FLTR_Quantitative: {\r\n          filters.push(FiltersConverter.convertQuantitativeFilterPresModel(filterPm));\r\n          break;\r\n        }\r\n\r\n        case PresLayerFilterType.FLTR_RelativeDate: {\r\n          filters.push(FiltersConverter.convertRelativeDateFilterPresModel(filterPm));\r\n          break;\r\n        }\r\n\r\n        default:\r\n          return;\r\n      }\r\n    });\r\n    return filters;\r\n  }\r\n\r\n  public static convertCategoricalFilterPresModel(filterPm: FilterInfoPresModel): CategoricalFilter {\r\n    let selectedValues: DataValue[] = filterPm.categoricalFilterInfo.captionedFilterValueList.map(filterValue => {\r\n      return FiltersConverter.convertFilterValuePresModel(filterValue);\r\n    });\r\n    let filter: CategoricalFilter = {\r\n      values: selectedValues,\r\n      isExclude: filterPm.categoricalFilterInfo.exclude,\r\n      filterType: FilterType.Categorical,\r\n      fieldCaption: filterPm.fieldCaption,\r\n      fieldName: filterPm.fn,\r\n      visualId: PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel)\r\n    };\r\n    return filter;\r\n  }\r\n\r\n  public static convertQuantitativeFilterPresModel(filterPm: FilterInfoPresModel): RangeFilter {\r\n    let minValue: DataValue = FiltersConverter.convertFilterValuePresModel(\r\n      filterPm.quantitativeFilterInfo.captionedRangeMin\r\n    );\r\n    let maxValue: DataValue = FiltersConverter.convertFilterValuePresModel(\r\n      filterPm.quantitativeFilterInfo.captionedRangeMax\r\n    );\r\n    let filter: RangeFilter = {\r\n      filterType: FilterType.Range,\r\n      fieldCaption: filterPm.fieldCaption,\r\n      fieldName: filterPm.fn,\r\n      visualId: PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel),\r\n      min: minValue,\r\n      max: maxValue,\r\n      includeNullValues: FiltersConverter.convertIncludedNullValues(filterPm.quantitativeFilterInfo.included)\r\n    };\r\n    return filter;\r\n  }\r\n\r\n  public static convertRelativeDateFilterPresModel(filterPm: FilterInfoPresModel): RelativeDateFilter {\r\n    let anchorDateValue: DataValue = FiltersConverter.convertFilterValuePresModel(\r\n      filterPm.relativeDateFilterInfo.captionedAnchorDate\r\n    );\r\n    let filter: RelativeDateFilter = {\r\n      filterType: FilterType.RelativeDate,\r\n      fieldCaption: filterPm.fieldCaption,\r\n      fieldName: filterPm.fn,\r\n      visualId: PresLayerToApiConverter.convertVisualId(filterPm.visualIdPresModel),\r\n      anchorDate: anchorDateValue,\r\n      periodType: EnumMappings.dateStepPeriod.convert(filterPm.relativeDateFilterInfo.datePeriodType),\r\n      rangeType: EnumMappings.dateRangeType.convert(filterPm.relativeDateFilterInfo.dateRangeType),\r\n      rangeN: filterPm.relativeDateFilterInfo.rangeN\r\n    };\r\n    return filter;\r\n  }\r\n\r\n  public static convertCategoricalDomain(domainPm: CategoricalDomainPresModel): CategoricalDomain {\r\n    let domainValues: Array<DataValue> = domainPm.captionedFilterValueList.map(filterValue => {\r\n      return FiltersConverter.convertFilterValuePresModel(filterValue);\r\n    });\r\n    return { values: domainValues};\r\n  }\r\n\r\n  public static convertQuantitativeDomain(domainPm: QuantitativeDomainPresModel): RangeDomain {\r\n    let minValue: DataValue = FiltersConverter.convertFilterValuePresModel(domainPm.captionedRangeMin);\r\n    let maxValue: DataValue = FiltersConverter.convertFilterValuePresModel(domainPm.captionedRangeMax);\r\n    return {\r\n      max: maxValue,\r\n      min: minValue\r\n    };\r\n  }\r\n\r\n  public static convertFilterValuePresModel(dvPM: FilterValuePresModel): DataValue {\r\n    /*tslint:disable-next-line:no-any */\r\n    let value: any;\r\n    switch (dvPM.dataType) {\r\n      case DataType.DT_BOOLEAN: {\r\n        value = Boolean(dvPM.dataValueStr);\r\n        break;\r\n      }\r\n      case DataType.DT_DATE: {\r\n        value = new Date(dvPM.dataValueStr);\r\n        break;\r\n      }\r\n      case DataType.DT_DATETIME: {\r\n        value = new Date(dvPM.dataValueStr);\r\n        break;\r\n      }\r\n      case DataType.DT_INTEGER: {\r\n        value = Number.parseInt(dvPM.dataValueStr);\r\n        break;\r\n      }\r\n      case DataType.DT_REAL: {\r\n        value = Number.parseFloat(dvPM.dataValueStr);\r\n        break;\r\n      }\r\n      // default to string\r\n      default: {\r\n        value = dvPM.dataValueStr;\r\n        break;\r\n      }\r\n    }\r\n    return {\r\n      value: value,\r\n      // TODO: no easy way of getting back aliased value from platform, will need to investigate further\r\n      aliasedValue: '',\r\n      formattedValue: dvPM.dataValueDisplayString\r\n    };\r\n  }\r\n\r\n  public static convertIncludedNullValues(includeNull: IncludedValues): boolean {\r\n    return (includeNull === IncludedValues.InRangeOrNull ||\r\n      includeNull === IncludedValues.All ||\r\n      includeNull === IncludedValues.Null\r\n    );\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/FiltersConverter.ts\n **/","import { TableauException } from '@tableau/api-utils';\r\n/**\r\n * Simple registry class which creates a mapping based on two keys.\r\n *\r\n * @export\r\n * @class MappingRegistry\r\n * @template TInputEnumType\r\n * @template TOutputEnumType\r\n * @template TMappingStorageType\r\n */\r\nexport class MappingRegistry<TInputEnumType extends string, TOutputEnumType extends string, TMappingStorageType> {\r\n  private static MISSING_REQUESTED_MAPPING: string = 'Missing requested mapping: %1 to %2';\r\n  private _registry: { [key: string]: TMappingStorageType };\r\n\r\n  public constructor() {\r\n    this._registry = {};\r\n  }\r\n\r\n  public has(inputType: TInputEnumType, outputType: TOutputEnumType): boolean {\r\n    const key = this.makeKey(inputType, outputType);\r\n    if (!this._registry.hasOwnProperty(key)) {\r\n      return false;\r\n    }\r\n\r\n    if (!this._registry[key]) {\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  public get(inputType: TInputEnumType, outputType: TOutputEnumType): TMappingStorageType {\r\n    if (!this.has(inputType, outputType)) {\r\n      throw TableauException.error(MappingRegistry.MISSING_REQUESTED_MAPPING, [inputType, outputType]);\r\n    }\r\n\r\n    const key = this.makeKey(inputType, outputType);\r\n    return this._registry[key];\r\n  }\r\n\r\n  public addRegistration(inputType: TInputEnumType, outputType: TOutputEnumType, storageItem: TMappingStorageType): void {\r\n    const key = this.makeKey(inputType, outputType);\r\n\r\n    // Add this item\r\n    this._registry[key] = storageItem;\r\n  }\r\n\r\n  /**\r\n   * Combines the two keys into a unique string\r\n   *\r\n   * @private\r\n   * @param {TInputEnumType} inputType\r\n   * @param {TOutputEnumType} outputType\r\n   * @returns {string}\r\n   * @memberof MappingRegistry\r\n   */\r\n  private makeKey(inputType: TInputEnumType, outputType: TOutputEnumType): string {\r\n    const keyObj = { input: inputType, output: outputType };\r\n    return JSON.stringify(keyObj);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/MappingRegistry.ts\n **/","import { DataType, DataValue, DomainRestrictionType, ParameterInfo } from '@tableau/api-internal-contract';\r\nimport { TableauException } from '@tableau/api-utils';\r\n\r\nimport { ParameterCtrlPresModel } from '../../gen-src/preslayer/PresModels';\r\nimport { PresLayerToApiEnumMappings as EnumMapping } from './EnumMappings';\r\n\r\n/**\r\n * Contains logic for converting Parameter models into their equivalent Api versions\r\n */\r\nexport class ParametersDataConverter {\r\n  public static convertParameterList(parameters: Array<ParameterCtrlPresModel>): Array<ParameterInfo> {\r\n    return parameters.map(ParametersDataConverter.convertParameter);\r\n  }\r\n\r\n  // Converts a single parameter.\r\n  // Rough port of https://opengrok/source/xref/dev_nessie/workgroup/vqlweb/scriptsharp/src/UI/Api/ApiParameterHandler.cs#95\r\n  public static convertParameter(param: ParameterCtrlPresModel): ParameterInfo {\r\n    const currentValue = ParametersDataConverter.convertAliasedDataValue(param.valueAlias, param.formattedValue);\r\n    const allowableValuesType = EnumMapping.parameterTypesDomainType.convert(param.parameterDomainType);\r\n\r\n    const result: ParameterInfo = {\r\n      name: param.fieldCaption,\r\n      fieldName: param.parameterName,\r\n      dataType: EnumMapping.dataType.convert(param.dataType),\r\n      currentValue: currentValue,\r\n      allowableValuesType: allowableValuesType\r\n    };\r\n\r\n    if (allowableValuesType === DomainRestrictionType.List) {\r\n      const allowableValues = new Array<DataValue>();\r\n      for (let i = 0; i < param.valuesAliases.length; i++) {\r\n        const adv = param.valuesAliases[i];\r\n        const formattedValue = param.formattedValues[i];\r\n        allowableValues.push(ParametersDataConverter.convertAliasedDataValue(adv, formattedValue));\r\n      }\r\n\r\n      result.allowableValues = allowableValues;\r\n\r\n    } else if (allowableValuesType === DomainRestrictionType.Range) {\r\n      result.minValue = ParametersDataConverter.makeDataValue(param.valueMin, param.formattedMin);\r\n      result.maxValue = ParametersDataConverter.makeDataValue(param.valueMax, param.formattedMax);\r\n      result.stepSize = ParametersDataConverter.convertNumber(result.dataType, param.valueInc);\r\n      result.dateStepPeriod = EnumMapping.dateStepPeriod.convert(param.datePeriodType, false);\r\n    } else {\r\n      // Nothing to do in the case that all values are allowed\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  private static convertNumber(dataType: DataType, value: string): number | undefined {\r\n    if (value) {\r\n      if (dataType === DataType.Int || dataType === DataType.Date || dataType === DataType.DateTime) {\r\n        return parseInt(value, 10);\r\n      } else if (dataType === DataType.Float) {\r\n        return parseFloat(value);\r\n      }\r\n    }\r\n\r\n    return undefined;\r\n  }\r\n\r\n  /*tslint:disable-next-line:no-any */\r\n  private static makeDataValue(value: any, formattedValue: string, alias?: string): DataValue {\r\n    const result: DataValue = {\r\n      value: value,\r\n      formattedValue: formattedValue,\r\n      aliasedValue: alias || formattedValue\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  /*tslint:disable-next-line:no-any */\r\n  private static convertAliasedDataValue(adv: any[], formattedValue: string): DataValue {\r\n    // AliasedDataValues are serialized in kind of a strange way from the platform code. They are output\r\n    // as an array of 2 values. The first is the actual value, the second is the alias. See AliasedDataValueSerializer::ToSerializer\r\n    if (!adv || !(adv instanceof Array)) {\r\n      throw TableauException.invalid(['aliased data value']);\r\n    }\r\n\r\n    const value = adv[0];\r\n    const alias = adv.length < 2 ? undefined : adv[1] as string;\r\n\r\n    return ParametersDataConverter.makeDataValue(value, formattedValue, alias);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** D:/dev/js-api/api-core/src/mappings/ParametersDataConverter.ts\n **/","import { AddInInstancePresModel } from '@tableau/api-core';\r\nimport * as contract from '@tableau/preslayer-api-contract';\r\n\r\nimport {\r\n  AddInApiPresLayerInteropObject,\r\n  Notification as PresLayerNotification,\r\n} from './types/AddInApiPresLayerInteropObject';\r\n\r\n/**\r\n * Implemenation of the PresentationLayer contract with a bit of extra information\r\n * added to work with add-ins. Most work is delegated down to the interopObject which\r\n * communicates directly with the c++ layer via QWebChannel\r\n *\r\n * @class AddInApiPresLayerImpl\r\n * @implements {contract.PresentationLayer}\r\n */\r\nexport class AddInApiPresLayerImpl implements contract.PresentationLayer {\r\n    private _notificationHandlers: { [eventid: string]: [contract.NotificationHandler] };\r\n\r\n    public constructor(private _interopObject: AddInApiPresLayerInteropObject) {\r\n        this._notificationHandlers = {};\r\n        if (_interopObject && _interopObject.OnNotification) {\r\n            _interopObject.OnNotification.connect(notification => {\r\n                this.dispatchNotification(notification);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the instance info for this particular add-in from the c++ code\r\n     *\r\n     * @readonly\r\n     * @type {AddInInstancePresModel}\r\n     * @memberof AddInApiPresLayerImpl\r\n     */\r\n    public get AddInInstanceInfo(): AddInInstancePresModel {\r\n        return this._interopObject.addInInstanceInfo as AddInInstancePresModel;\r\n    }\r\n\r\n    /**\r\n     * Invokes a command using the pres-layer interop\r\n     *\r\n     * @template T - The expected return type\r\n     * @param {string} commandNamespace\r\n     * @param {string} commandName\r\n     * @param {object} params\r\n     * @returns {Promise<T>}\r\n     * @memberof AddInApiPresLayerImpl\r\n     */\r\n    public invokeCommand<T>(commandNamespace: string, commandName: string, params: object): Promise<T> {\r\n        return new Promise((resolve, reject) => {\r\n            try {\r\n                commandNamespace = commandNamespace || 'tabdoc';\r\n                this._interopObject.ExecuteCommand<T>(\r\n                    commandNamespace,\r\n                    commandName,\r\n                    params,\r\n                    response => {\r\n                        if (!response.Success) {\r\n                            let msg = 'ExecuteCommand failed, with result:' + JSON.stringify(response.Result);\r\n                            reject(new Error(msg));\r\n                        } else {\r\n                            resolve(response.Result);\r\n                        }\r\n                    });\r\n            } catch (err) {\r\n                reject(err);\r\n            }\r\n        });\r\n    }\r\n\r\n    // This implementation will registration a single instance of a notification handler with the Native C++ object,\r\n    // and implement multi-dispatch to the web objects from h.ere\r\n    public registerNotificationHandler(eventId: string, handler: contract.NotificationHandler): () => void {\r\n        if (eventId in this._notificationHandlers) {\r\n            this._notificationHandlers[eventId].push(handler);\r\n        } else {\r\n            this._notificationHandlers[eventId] = [handler];\r\n            try {\r\n                this._interopObject.RegisterNotificationHandler(eventId);\r\n            } catch (err) {\r\n                // console.log('RegisterNotificationHandler failed: ' + err);\r\n            }\r\n        }\r\n        return () => this.removeNotificationHandler(eventId, handler);\r\n    }\r\n\r\n    private removeNotificationHandler(eventId: string, handler: contract.NotificationHandler): void {\r\n        const handlerList = this._notificationHandlers[eventId];\r\n        if (!handlerList) {\r\n            return;\r\n        }\r\n        const foundIndex = handlerList.indexOf(handler);\r\n        if (foundIndex >= 0) {\r\n            handlerList.splice(foundIndex, 1);\r\n        }\r\n        if (handlerList.length === 0) {\r\n            delete this._notificationHandlers[eventId];\r\n        }\r\n    }\r\n    private dispatchNotification(notification: PresLayerNotification): void {\r\n        // console.log('received notification: ' + JSON.stringify(notification));\r\n        let eventId = notification.eventId;\r\n        let presModel = notification.presModel;\r\n        if (eventId in this._notificationHandlers) {\r\n            let handlers = this._notificationHandlers[eventId];\r\n            for (let i = handlers.length - 1; i >= 0; i--) {\r\n                handlers[i](presModel);\r\n            }\r\n        }\r\n    }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** ../src/AddInApiPresLayerImpl.ts\n **/","import { ApiEventHandler } from '@tableau/api-core';\r\nimport {\r\n  ExecuteParameters,\r\n  ExecuteResponse,\r\n  InternalApiDispatcher,\r\n  NotificationHandler,\r\n  VerbId,\r\n  VersionNumber,\r\n} from '@tableau/api-internal-contract';\r\n\r\n/**\r\n * Implementation of the InternalApiDispatcher for desktop. Since this will run in the same\r\n * frame as the ApiEventHandler, this class mostly just marshalls down to that implementation\r\n *\r\n * @export\r\n * @class DesktopApiDispatcher\r\n * @implements {InternalApiDispatcher}\r\n */\r\nexport class DesktopApiDispatcher implements InternalApiDispatcher {\r\n  private _notificationHandlers: Array<NotificationHandler>;\r\n\r\n  public constructor(private _apiEventHandler: ApiEventHandler) {\r\n    this._notificationHandlers = [];\r\n    this._apiEventHandler.setEventHandler((notificationId, model) => {\r\n      this._notificationHandlers.forEach(handler => handler({\r\n        notificationId: notificationId,\r\n        data: model\r\n      }));\r\n    });\r\n  }\r\n\r\n  public setVersionNumber(versionNumber: VersionNumber): void {\r\n    this._apiEventHandler.setVersionNumber(versionNumber);\r\n  }\r\n\r\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\r\n    // Just pass this right through to the ApiEventHandler\r\n    return this._apiEventHandler.execute(verb, parameters);\r\n  }\r\n\r\n  public registerNotificationHandler(handler: NotificationHandler): void {\r\n    this._notificationHandlers.push(handler);\r\n  }\r\n\r\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\r\n    this._notificationHandlers = this._notificationHandlers.filter(h => h !== handler);\r\n  }\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** ../src/DesktopApiDispatcher.ts\n **/","import './types/QtTypes';\r\n\r\nimport { QWebChannel } from 'qwebchannel';\r\n\r\nimport { AddInApiPresLayerInteropObject } from './types/AddInApiPresLayerInteropObject';\r\n\r\n/**\r\n * Initializes the QWebChannel contract and returns the pres layer interop object\r\n *\r\n * @returns {Promise<AddInApiPresLayerInteropObject>}\r\n */\r\nexport function initializeWebChannelPresLayer(): Promise<AddInApiPresLayerInteropObject> {\r\n  return new Promise<AddInApiPresLayerInteropObject>((resolve, reject) => {\r\n    try {\r\n\r\n      // tslint:disable-next-line\r\n      new QWebChannel(qt.webChannelTransport, (channel) => {\r\n\r\n        // tslint:disable-next-line\r\n        const addInPresLayer = channel.objects['addInPresLayer'] as AddInApiPresLayerInteropObject;\r\n        resolve(addInPresLayer);\r\n      });\r\n    } catch (e) {\r\n      reject(e);\r\n    }\r\n  });\r\n}\r\n\r\nexport function hasQt(): boolean {\r\n  return typeof qt === 'object';\r\n}\r\n\n\n\n/** WEBPACK FOOTER **\n ** ../src/QtWebChannelImpl.ts\n **/","/****************************************************************************\n**\n** Copyright (C) 2015 The Qt Company Ltd.\n** Copyright (C) 2014 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>\n** Contact: http://www.qt.io/licensing/\n**\n** This file is part of the QtWebChannel module of the Qt Toolkit.\n**\n** $QT_BEGIN_LICENSE:LGPL21$\n** Commercial License Usage\n** Licensees holding valid commercial Qt licenses may use this file in\n** accordance with the commercial license agreement provided with the\n** Software or, alternatively, in accordance with the terms contained in\n** a written agreement between you and The Qt Company. For licensing terms\n** and conditions see http://www.qt.io/terms-conditions. For further\n** information use the contact form at http://www.qt.io/contact-us.\n**\n** GNU Lesser General Public License Usage\n** Alternatively, this file may be used under the terms of the GNU Lesser\n** General Public License version 2.1 or version 3 as published by the Free\n** Software Foundation and appearing in the file LICENSE.LGPLv21 and\n** LICENSE.LGPLv3 included in the packaging of this file. Please review the\n** following information to ensure the GNU Lesser General Public License\n** requirements will be met: https://www.gnu.org/licenses/lgpl.html and\n** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.\n**\n** As a special exception, The Qt Company gives you certain additional\n** rights. These rights are described in The Qt Company LGPL Exception\n** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.\n**\n** $QT_END_LICENSE$\n**\n****************************************************************************/\n\n\"use strict\";\n\nvar QWebChannelMessageTypes = {\n    signal: 1,\n    propertyUpdate: 2,\n    init: 3,\n    idle: 4,\n    debug: 5,\n    invokeMethod: 6,\n    connectToSignal: 7,\n    disconnectFromSignal: 8,\n    setProperty: 9,\n    response: 10,\n};\n\nvar QWebChannel = function(transport, initCallback)\n{\n    if (typeof transport !== \"object\" || typeof transport.send !== \"function\") {\n        console.error(\"The QWebChannel expects a transport object with a send function and onmessage callback property.\" +\n                      \" Given is: transport: \" + typeof(transport) + \", transport.send: \" + typeof(transport.send));\n        return;\n    }\n\n    var channel = this;\n    this.transport = transport;\n\n    this.send = function(data)\n    {\n        if (typeof(data) !== \"string\") {\n            data = JSON.stringify(data);\n        }\n        channel.transport.send(data);\n    }\n\n    this.transport.onmessage = function(message)\n    {\n        var data = message.data;\n        if (typeof data === \"string\") {\n            data = JSON.parse(data);\n        }\n        switch (data.type) {\n            case QWebChannelMessageTypes.signal:\n                channel.handleSignal(data);\n                break;\n            case QWebChannelMessageTypes.response:\n                channel.handleResponse(data);\n                break;\n            case QWebChannelMessageTypes.propertyUpdate:\n                channel.handlePropertyUpdate(data);\n                break;\n            default:\n                console.error(\"invalid message received:\", message.data);\n                break;\n        }\n    }\n\n    this.execCallbacks = {};\n    this.execId = 0;\n    this.exec = function(data, callback)\n    {\n        if (!callback) {\n            // if no callback is given, send directly\n            channel.send(data);\n            return;\n        }\n        if (channel.execId === Number.MAX_VALUE) {\n            // wrap\n            channel.execId = Number.MIN_VALUE;\n        }\n        if (data.hasOwnProperty(\"id\")) {\n            console.error(\"Cannot exec message with property id: \" + JSON.stringify(data));\n            return;\n        }\n        data.id = channel.execId++;\n        channel.execCallbacks[data.id] = callback;\n        channel.send(data);\n    };\n\n    this.objects = {};\n\n    this.handleSignal = function(message)\n    {\n        var object = channel.objects[message.object];\n        if (object) {\n            object.signalEmitted(message.signal, message.args);\n        } else {\n            console.warn(\"Unhandled signal: \" + message.object + \"::\" + message.signal);\n        }\n    }\n\n    this.handleResponse = function(message)\n    {\n        if (!message.hasOwnProperty(\"id\")) {\n            console.error(\"Invalid response message received: \", JSON.stringify(message));\n            return;\n        }\n        channel.execCallbacks[message.id](message.data);\n        delete channel.execCallbacks[message.id];\n    }\n\n    this.handlePropertyUpdate = function(message)\n    {\n        for (var i in message.data) {\n            var data = message.data[i];\n            var object = channel.objects[data.object];\n            if (object) {\n                object.propertyUpdate(data.signals, data.properties);\n            } else {\n                console.warn(\"Unhandled property update: \" + data.object + \"::\" + data.signal);\n            }\n        }\n        channel.exec({type: QWebChannelMessageTypes.idle});\n    }\n\n    this.debug = function(message)\n    {\n        channel.send({type: QWebChannelMessageTypes.debug, data: message});\n    };\n\n    channel.exec({type: QWebChannelMessageTypes.init}, function(data) {\n        for (var objectName in data) {\n            var object = new QObject(objectName, data[objectName], channel);\n        }\n        // now unwrap properties, which might reference other registered objects\n        for (var objectName in channel.objects) {\n            channel.objects[objectName].unwrapProperties();\n        }\n        if (initCallback) {\n            initCallback(channel);\n        }\n        channel.exec({type: QWebChannelMessageTypes.idle});\n    });\n};\n\nfunction QObject(name, data, webChannel)\n{\n    this.__id__ = name;\n    webChannel.objects[name] = this;\n\n    // List of callbacks that get invoked upon signal emission\n    this.__objectSignals__ = {};\n\n    // Cache of all properties, updated when a notify signal is emitted\n    this.__propertyCache__ = {};\n\n    var object = this;\n\n    // ----------------------------------------------------------------------\n\n    this.unwrapQObject = function(response)\n    {\n        if (response instanceof Array) {\n            // support list of objects\n            var ret = new Array(response.length);\n            for (var i = 0; i < response.length; ++i) {\n                ret[i] = object.unwrapQObject(response[i]);\n            }\n            return ret;\n        }\n        if (!response\n            || !response[\"__QObject*__\"]\n            || response[\"id\"] === undefined) {\n            return response;\n        }\n\n        var objectId = response.id;\n        if (webChannel.objects[objectId])\n            return webChannel.objects[objectId];\n\n        if (!response.data) {\n            console.error(\"Cannot unwrap unknown QObject \" + objectId + \" without data.\");\n            return;\n        }\n\n        var qObject = new QObject( objectId, response.data, webChannel );\n        qObject.destroyed.connect(function() {\n            if (webChannel.objects[objectId] === qObject) {\n                delete webChannel.objects[objectId];\n                // reset the now deleted QObject to an empty {} object\n                // just assigning {} though would not have the desired effect, but the\n                // below also ensures all external references will see the empty map\n                // NOTE: this detour is necessary to workaround QTBUG-40021\n                var propertyNames = [];\n                for (var propertyName in qObject) {\n                    propertyNames.push(propertyName);\n                }\n                for (var idx in propertyNames) {\n                    delete qObject[propertyNames[idx]];\n                }\n            }\n        });\n        // here we are already initialized, and thus must directly unwrap the properties\n        qObject.unwrapProperties();\n        return qObject;\n    }\n\n    this.unwrapProperties = function()\n    {\n        for (var propertyIdx in object.__propertyCache__) {\n            object.__propertyCache__[propertyIdx] = object.unwrapQObject(object.__propertyCache__[propertyIdx]);\n        }\n    }\n\n    function addSignal(signalData, isPropertyNotifySignal)\n    {\n        var signalName = signalData[0];\n        var signalIndex = signalData[1];\n        object[signalName] = {\n            connect: function(callback) {\n                if (typeof(callback) !== \"function\") {\n                    console.error(\"Bad callback given to connect to signal \" + signalName);\n                    return;\n                }\n\n                object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];\n                object.__objectSignals__[signalIndex].push(callback);\n\n                if (!isPropertyNotifySignal && signalName !== \"destroyed\") {\n                    // only required for \"pure\" signals, handled separately for properties in propertyUpdate\n                    // also note that we always get notified about the destroyed signal\n                    webChannel.exec({\n                        type: QWebChannelMessageTypes.connectToSignal,\n                        object: object.__id__,\n                        signal: signalIndex\n                    });\n                }\n            },\n            disconnect: function(callback) {\n                if (typeof(callback) !== \"function\") {\n                    console.error(\"Bad callback given to disconnect from signal \" + signalName);\n                    return;\n                }\n                object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];\n                var idx = object.__objectSignals__[signalIndex].indexOf(callback);\n                if (idx === -1) {\n                    console.error(\"Cannot find connection of signal \" + signalName + \" to \" + callback.name);\n                    return;\n                }\n                object.__objectSignals__[signalIndex].splice(idx, 1);\n                if (!isPropertyNotifySignal && object.__objectSignals__[signalIndex].length === 0) {\n                    // only required for \"pure\" signals, handled separately for properties in propertyUpdate\n                    webChannel.exec({\n                        type: QWebChannelMessageTypes.disconnectFromSignal,\n                        object: object.__id__,\n                        signal: signalIndex\n                    });\n                }\n            }\n        };\n    }\n\n    /**\n     * Invokes all callbacks for the given signalname. Also works for property notify callbacks.\n     */\n    function invokeSignalCallbacks(signalName, signalArgs)\n    {\n        var connections = object.__objectSignals__[signalName];\n        if (connections) {\n            connections.forEach(function(callback) {\n                callback.apply(callback, signalArgs);\n            });\n        }\n    }\n\n    this.propertyUpdate = function(signals, propertyMap)\n    {\n        // update property cache\n        for (var propertyIndex in propertyMap) {\n            var propertyValue = propertyMap[propertyIndex];\n            object.__propertyCache__[propertyIndex] = propertyValue;\n        }\n\n        for (var signalName in signals) {\n            // Invoke all callbacks, as signalEmitted() does not. This ensures the\n            // property cache is updated before the callbacks are invoked.\n            invokeSignalCallbacks(signalName, signals[signalName]);\n        }\n    }\n\n    this.signalEmitted = function(signalName, signalArgs)\n    {\n        invokeSignalCallbacks(signalName, signalArgs);\n    }\n\n    function addMethod(methodData)\n    {\n        var methodName = methodData[0];\n        var methodIdx = methodData[1];\n        object[methodName] = function() {\n            var args = [];\n            var callback;\n            for (var i = 0; i < arguments.length; ++i) {\n                if (typeof arguments[i] === \"function\")\n                    callback = arguments[i];\n                else\n                    args.push(arguments[i]);\n            }\n\n            webChannel.exec({\n                \"type\": QWebChannelMessageTypes.invokeMethod,\n                \"object\": object.__id__,\n                \"method\": methodIdx,\n                \"args\": args\n            }, function(response) {\n                if (response !== undefined) {\n                    var result = object.unwrapQObject(response);\n                    if (callback) {\n                        (callback)(result);\n                    }\n                }\n            });\n        };\n    }\n\n    function bindGetterSetter(propertyInfo)\n    {\n        var propertyIndex = propertyInfo[0];\n        var propertyName = propertyInfo[1];\n        var notifySignalData = propertyInfo[2];\n        // initialize property cache with current value\n        // NOTE: if this is an object, it is not directly unwrapped as it might\n        // reference other QObject that we do not know yet\n        object.__propertyCache__[propertyIndex] = propertyInfo[3];\n\n        if (notifySignalData) {\n            if (notifySignalData[0] === 1) {\n                // signal name is optimized away, reconstruct the actual name\n                notifySignalData[0] = propertyName + \"Changed\";\n            }\n            addSignal(notifySignalData, true);\n        }\n\n        Object.defineProperty(object, propertyName, {\n            get: function () {\n                var propertyValue = object.__propertyCache__[propertyIndex];\n                if (propertyValue === undefined) {\n                    // This shouldn't happen\n                    console.warn(\"Undefined value in property cache for property \\\"\" + propertyName + \"\\\" in object \" + object.__id__);\n                }\n\n                return propertyValue;\n            },\n            set: function(value) {\n                if (value === undefined) {\n                    console.warn(\"Property setter for \" + propertyName + \" called with undefined value!\");\n                    return;\n                }\n                object.__propertyCache__[propertyIndex] = value;\n                webChannel.exec({\n                    \"type\": QWebChannelMessageTypes.setProperty,\n                    \"object\": object.__id__,\n                    \"property\": propertyIndex,\n                    \"value\": value\n                });\n            }\n        });\n\n    }\n\n    // ----------------------------------------------------------------------\n\n    data.methods.forEach(addMethod);\n\n    data.properties.forEach(bindGetterSetter);\n\n    data.signals.forEach(function(signal) { addSignal(signal, false); });\n\n    for (var name in data.enums) {\n        object[name] = data.enums[name];\n    }\n}\n\n//required for use with nodejs\nif (typeof module === 'object') {\n    module.exports = {\n        QWebChannel: QWebChannel\n    };\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ../~/qwebchannel/qwebchannel.js\n ** module id = 104\n ** module chunks = 0\n **/"],"sourceRoot":""} \ No newline at end of file From 6fa039e1109e89e0a3062317a0e1af88134b2d25 Mon Sep 17 00:00:00 2001 From: Brendan Lee Date: Tue, 28 Nov 2017 12:14:05 -0800 Subject: [PATCH 2/2] whitespace removal --- Samples/DataSources/datasources.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Samples/DataSources/datasources.html b/Samples/DataSources/datasources.html index 837fa47f..d5d74050 100644 --- a/Samples/DataSources/datasources.html +++ b/Samples/DataSources/datasources.html @@ -67,7 +67,7 @@

DataSource Details

Type - + Fields