@esri/solution-deployer 0.23.1 → 1.1.3

package/dist/umd/deployer.umd.js

@@ -1,7 +1,7 @@
 /* @preserve
-* @esri/solution-deployer - v0.23.1 - Apache-2.0
+* @esri/solution-deployer - v1.1.3 - Apache-2.0
 * Copyright (c) 2018-2021 Esri, Inc.
-* Fri Jun 04 2021 08:33:33 GMT-0700 (Pacific Daylight Time)
+* Mon Oct 18 2021 09:05:22 GMT-0700 (Pacific Daylight Time)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,1564 +16,1636 @@
 * limitations under the License.
 */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@esri/solution-common'), require('@esri/solution-feature-layer'), require('@esri/solution-file'), require('@esri/solution-form'), require('@esri/solution-group'), require('@esri/solution-simple-types'), require('@esri/solution-storymap'), require('@esri/solution-web-experience'), require('@esri/solution-hub-types'), require('@esri/hub-common'), require('@esri/arcgis-rest-portal')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@esri/solution-common', '@esri/solution-feature-layer', '@esri/solution-file', '@esri/solution-form', '@esri/solution-group', '@esri/solution-simple-types', '@esri/solution-storymap', '@esri/solution-web-experience', '@esri/solution-hub-types', '@esri/hub-common', '@esri/arcgis-rest-portal'], factory) :
-    (global = global || self, factory(global.arcgisSolution = global.arcgisSolution || {}, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisHub, global.arcgisRest));
-}(this, (function (exports, common, featureLayer, fileProcessor, formProcessor, group, solutionSimpleTypes, solutionStorymap, solutionWebExperience, solutionHubTypes, hubCommon, arcgisRestPortal) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@esri/solution-common'), require('@esri/solution-feature-layer'), require('@esri/solution-file'), require('@esri/solution-form'), require('@esri/solution-group'), require('@esri/solution-simple-types'), require('@esri/solution-storymap'), require('@esri/solution-velocity'), require('@esri/solution-web-experience'), require('@esri/solution-hub-types'), require('@esri/hub-common'), require('@esri/arcgis-rest-portal')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@esri/solution-common', '@esri/solution-feature-layer', '@esri/solution-file', '@esri/solution-form', '@esri/solution-group', '@esri/solution-simple-types', '@esri/solution-storymap', '@esri/solution-velocity', '@esri/solution-web-experience', '@esri/solution-hub-types', '@esri/hub-common', '@esri/arcgis-rest-portal'], factory) :
+  (global = global || self, factory(global.arcgisSolution = global.arcgisSolution || {}, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisSolution, global.arcgisHub, global.arcgisRest));
+}(this, (function (exports, common, featureLayer, fileProcessor, formProcessor, group, solutionSimpleTypes, solutionStorymap, solutionVelocity, solutionWebExperience, solutionHubTypes, hubCommon, portal) { 'use strict';
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
-
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
-
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spread() {
-        for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read(arguments[i]));
-        return ar;
-    }
+  /** @license
+   * Copyright 2020 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  const UNSUPPORTED = null;
+  /**
+   * Mapping from item type to module with type-specific template-handling code.
+   * AGO types come from a blend of arcgis-portal-app\src\js\arcgisonline\pages\item\_Info.js and
+   * arcgis-portal-app\src\js\arcgis-components\src\_utils\metadata\item\displayName.ts
+   */
+  const moduleMap = {
+      ////////////////////////////////////////////////////////
+      // Group type
+      Group: group,
+      ////////////////////////////////////////////////////////
+      // Layer types
+      "Big Data Analytic": solutionVelocity.VelocityProcessor,
+      "Feature Collection": solutionSimpleTypes.simpleTypes,
+      "Feature Service": featureLayer,
+      Feed: solutionVelocity.VelocityProcessor,
+      "Geocoding Service": undefined,
+      "Geodata Service": undefined,
+      "Geometry Service": undefined,
+      "Geoprocessing Service": undefined,
+      "Globe Service": undefined,
+      "Image Service": undefined,
+      KML: undefined,
+      "Map Service": featureLayer,
+      "Network Analysis Service": undefined,
+      "Real Time Analytic": solutionVelocity.VelocityProcessor,
+      "Relational Database Connection": undefined,
+      "Scene Service": undefined,
+      "Stream Service": undefined,
+      Tool: undefined,
+      "Vector Tile Service": undefined,
+      WFS: undefined,
+      WMS: undefined,
+      WMTS: undefined,
+      "Workflow Manager Service": undefined,
+      ////////////////////////////////////////////////////////
+      // Map types
+      "3D Web Scene": undefined,
+      "Web Map": solutionSimpleTypes.simpleTypes,
+      "Web Scene": solutionSimpleTypes.simpleTypes,
+      ////////////////////////////////////////////////////////
+      // App types
+      Application: undefined,
+      Dashboard: solutionSimpleTypes.simpleTypes,
+      "Data Store": undefined,
+      "Desktop Application": undefined,
+      "Excalibur Imagery Project": undefined,
+      Form: formProcessor,
+      "Hub Initiative": UNSUPPORTED,
+      "Hub Page": solutionHubTypes.HubPageProcessor,
+      "Hub Site Application": solutionHubTypes.HubSiteProcessor,
+      "Insights Model": solutionSimpleTypes.simpleTypes,
+      "Insights Page": undefined,
+      "Insights Theme": undefined,
+      "Insights Workbook": undefined,
+      Mission: undefined,
+      "Mobile Application": undefined,
+      Notebook: solutionSimpleTypes.notebookProcessor,
+      "Oriented Imagery Catalog": solutionSimpleTypes.simpleTypes,
+      "Ortho Mapping Project": undefined,
+      "QuickCapture Project": solutionSimpleTypes.quickcaptureProcessor,
+      "Site Application": solutionHubTypes.HubSiteProcessor,
+      "Site Page": solutionHubTypes.HubPageProcessor,
+      Solution: UNSUPPORTED,
+      StoryMap: solutionStorymap.StoryMapProcessor,
+      "Urban Model": undefined,
+      "Web Experience Template": undefined,
+      "Web Experience": solutionWebExperience.WebExperienceProcessor,
+      "Web Mapping Application": solutionSimpleTypes.simpleTypes,
+      "Workforce Project": solutionSimpleTypes.simpleTypes,
+      ////////////////////////////////////////////////////////
+      // File types
+      "360 VR Experience": fileProcessor,
+      "AppBuilder Extension": fileProcessor,
+      "AppBuilder Widget Package": fileProcessor,
+      "Application Configuration": fileProcessor,
+      "ArcGIS Pro Add In": fileProcessor,
+      "ArcGIS Pro Configuration": fileProcessor,
+      "ArcPad Package": fileProcessor,
+      "Basemap Package": fileProcessor,
+      "CAD Drawing": fileProcessor,
+      "CityEngine Web Scene": fileProcessor,
+      "Code Attachment": UNSUPPORTED,
+      "Code Sample": fileProcessor,
+      "Color Set": fileProcessor,
+      "Compact Tile Package": fileProcessor,
+      "CSV Collection": fileProcessor,
+      CSV: fileProcessor,
+      "Deep Learning Package": fileProcessor,
+      "Desktop Add In": fileProcessor,
+      "Desktop Application Template": fileProcessor,
+      "Desktop Style": fileProcessor,
+      "Document Link": fileProcessor,
+      "Explorer Add In": fileProcessor,
+      "Explorer Layer": fileProcessor,
+      "Explorer Map": fileProcessor,
+      "Feature Collection Template": fileProcessor,
+      "File Geodatabase": fileProcessor,
+      GeoJson: fileProcessor,
+      GeoPackage: fileProcessor,
+      "Geoprocessing Package": fileProcessor,
+      "Geoprocessing Sample": fileProcessor,
+      "Globe Document": fileProcessor,
+      "Image Collection": fileProcessor,
+      Image: fileProcessor,
+      "iWork Keynote": fileProcessor,
+      "iWork Numbers": fileProcessor,
+      "iWork Pages": fileProcessor,
+      "KML Collection": fileProcessor,
+      "Layer Package": fileProcessor,
+      "Layer Template": fileProcessor,
+      Layer: fileProcessor,
+      Layout: fileProcessor,
+      "Locator Package": fileProcessor,
+      "Map Document": fileProcessor,
+      "Map Package": fileProcessor,
+      "Map Template": fileProcessor,
+      "Microsoft Excel": fileProcessor,
+      "Microsoft Powerpoint": fileProcessor,
+      "Microsoft Word": fileProcessor,
+      "Mobile Basemap Package": fileProcessor,
+      "Mobile Map Package": fileProcessor,
+      "Mobile Scene Package": fileProcessor,
+      "Native Application": fileProcessor,
+      "Native Application Installer": fileProcessor,
+      "Native Application Template": fileProcessor,
+      netCDF: fileProcessor,
+      "Operation View": fileProcessor,
+      "Operations Dashboard Add In": fileProcessor,
+      "Operations Dashboard Extension": fileProcessor,
+      PDF: fileProcessor,
+      "Pro Layer Package": fileProcessor,
+      "Pro Layer": fileProcessor,
+      "Pro Map Package": fileProcessor,
+      "Pro Map": fileProcessor,
+      "Pro Report": fileProcessor,
+      "Project Package": fileProcessor,
+      "Project Template": fileProcessor,
+      "Published Map": fileProcessor,
+      "Raster function template": fileProcessor,
+      "Report Template": fileProcessor,
+      "Rule Package": fileProcessor,
+      "Scene Document": fileProcessor,
+      "Scene Package": fileProcessor,
+      "Service Definition": fileProcessor,
+      Shapefile: fileProcessor,
+      "Statistical Data Collection": fileProcessor,
+      Style: fileProcessor,
+      "Survey123 Add In": fileProcessor,
+      "Symbol Set": fileProcessor,
+      "Task File": fileProcessor,
+      "Tile Package": fileProcessor,
+      "Toolbox Package": fileProcessor,
+      "Vector Tile Package": fileProcessor,
+      "Viewer Configuration": fileProcessor,
+      "Visio Document": fileProcessor,
+      "Window Mobile Package": fileProcessor,
+      "Windows Mobile Package": fileProcessor,
+      "Windows Viewer Add In": fileProcessor,
+      "Windows Viewer Configuration": fileProcessor,
+      "Workflow Manager Package": fileProcessor,
+      ////////////////////////////////////////////////////////
+      // Testing "types"
+      Undefined: undefined,
+      Unsupported: UNSUPPORTED
+  };
 
-    /** @license
-     * Copyright 2020 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    var UNSUPPORTED = null;
-    /**
-     * Mapping from item type to module with type-specific template-handling code.
-     * AGO types come from a blend of arcgis-portal-app\src\js\arcgisonline\pages\item\_Info.js and
-     * arcgis-portal-app\src\js\arcgis-components\src\_utils\metadata\item\displayName.ts
-     */
-    var moduleMap = {
-        ////////////////////////////////////////////////////////
-        // Group type
-        Group: group,
-        ////////////////////////////////////////////////////////
-        // Layer types
-        "Big Data Analytic": undefined,
-        "Feature Collection": solutionSimpleTypes.simpleTypes,
-        "Feature Service": featureLayer,
-        Feed: undefined,
-        "Geocoding Service": undefined,
-        "Geodata Service": undefined,
-        "Geometry Service": undefined,
-        "Geoprocessing Service": undefined,
-        "Globe Service": undefined,
-        "Image Service": undefined,
-        KML: undefined,
-        "Map Service": featureLayer,
-        "Network Analysis Service": undefined,
-        "Real Time Analytic": undefined,
-        "Relational Database Connection": undefined,
-        "Scene Service": undefined,
-        "Stream Service": undefined,
-        Tool: undefined,
-        "Vector Tile Service": undefined,
-        WFS: undefined,
-        WMS: undefined,
-        WMTS: undefined,
-        "Workflow Manager Service": undefined,
-        ////////////////////////////////////////////////////////
-        // Map types
-        "3D Web Scene": undefined,
-        "Web Map": solutionSimpleTypes.simpleTypes,
-        "Web Scene": undefined,
-        ////////////////////////////////////////////////////////
-        // App types
-        Application: undefined,
-        Dashboard: solutionSimpleTypes.simpleTypes,
-        "Data Store": undefined,
-        "Desktop Application": undefined,
-        "Excalibur Imagery Project": undefined,
-        Form: formProcessor,
-        "Hub Initiative": UNSUPPORTED,
-        "Hub Page": solutionHubTypes.HubPageProcessor,
-        "Hub Site Application": solutionHubTypes.HubSiteProcessor,
-        "Insights Model": solutionSimpleTypes.simpleTypes,
-        "Insights Page": undefined,
-        "Insights Theme": undefined,
-        "Insights Workbook": undefined,
-        Mission: undefined,
-        "Mobile Application": undefined,
-        Notebook: solutionSimpleTypes.notebookProcessor,
-        "Oriented Imagery Catalog": solutionSimpleTypes.simpleTypes,
-        "Ortho Mapping Project": undefined,
-        "QuickCapture Project": solutionSimpleTypes.quickcaptureProcessor,
-        "Site Application": solutionHubTypes.HubSiteProcessor,
-        "Site Page": solutionHubTypes.HubPageProcessor,
-        Solution: UNSUPPORTED,
-        StoryMap: solutionStorymap.StoryMapProcessor,
-        "Urban Model": undefined,
-        "Web Experience Template": undefined,
-        "Web Experience": solutionWebExperience.WebExperienceProcessor,
-        "Web Mapping Application": solutionSimpleTypes.simpleTypes,
-        "Workforce Project": solutionSimpleTypes.simpleTypes,
-        ////////////////////////////////////////////////////////
-        // File types
-        "360 VR Experience": fileProcessor,
-        "AppBuilder Extension": fileProcessor,
-        "AppBuilder Widget Package": fileProcessor,
-        "Application Configuration": fileProcessor,
-        "ArcGIS Pro Add In": fileProcessor,
-        "ArcGIS Pro Configuration": fileProcessor,
-        "ArcPad Package": fileProcessor,
-        "Basemap Package": fileProcessor,
-        "CAD Drawing": fileProcessor,
-        "CityEngine Web Scene": fileProcessor,
-        "Code Attachment": UNSUPPORTED,
-        "Code Sample": fileProcessor,
-        "Color Set": fileProcessor,
-        "Compact Tile Package": fileProcessor,
-        "CSV Collection": fileProcessor,
-        CSV: fileProcessor,
-        "Deep Learning Package": fileProcessor,
-        "Desktop Add In": fileProcessor,
-        "Desktop Application Template": fileProcessor,
-        "Desktop Style": fileProcessor,
-        "Document Link": fileProcessor,
-        "Explorer Add In": fileProcessor,
-        "Explorer Layer": fileProcessor,
-        "Explorer Map": fileProcessor,
-        "Feature Collection Template": fileProcessor,
-        "File Geodatabase": fileProcessor,
-        GeoJson: fileProcessor,
-        GeoPackage: fileProcessor,
-        "Geoprocessing Package": fileProcessor,
-        "Geoprocessing Sample": fileProcessor,
-        "Globe Document": fileProcessor,
-        "Image Collection": fileProcessor,
-        Image: fileProcessor,
-        "iWork Keynote": fileProcessor,
-        "iWork Numbers": fileProcessor,
-        "iWork Pages": fileProcessor,
-        "KML Collection": fileProcessor,
-        "Layer Package": fileProcessor,
-        "Layer Template": fileProcessor,
-        Layer: fileProcessor,
-        Layout: fileProcessor,
-        "Locator Package": fileProcessor,
-        "Map Document": fileProcessor,
-        "Map Package": fileProcessor,
-        "Map Template": fileProcessor,
-        "Microsoft Excel": fileProcessor,
-        "Microsoft Powerpoint": fileProcessor,
-        "Microsoft Word": fileProcessor,
-        "Mobile Basemap Package": fileProcessor,
-        "Mobile Map Package": fileProcessor,
-        "Mobile Scene Package": fileProcessor,
-        "Native Application": fileProcessor,
-        "Native Application Installer": fileProcessor,
-        "Native Application Template": fileProcessor,
-        netCDF: fileProcessor,
-        "Operation View": fileProcessor,
-        "Operations Dashboard Add In": fileProcessor,
-        "Operations Dashboard Extension": fileProcessor,
-        PDF: fileProcessor,
-        "Pro Layer Package": fileProcessor,
-        "Pro Layer": fileProcessor,
-        "Pro Map Package": fileProcessor,
-        "Pro Map": fileProcessor,
-        "Pro Report": fileProcessor,
-        "Project Package": fileProcessor,
-        "Project Template": fileProcessor,
-        "Published Map": fileProcessor,
-        "Raster function template": fileProcessor,
-        "Report Template": fileProcessor,
-        "Rule Package": fileProcessor,
-        "Scene Document": fileProcessor,
-        "Scene Package": fileProcessor,
-        "Service Definition": fileProcessor,
-        Shapefile: fileProcessor,
-        "Statistical Data Collection": fileProcessor,
-        Style: fileProcessor,
-        "Survey123 Add In": fileProcessor,
-        "Symbol Set": fileProcessor,
-        "Task File": fileProcessor,
-        "Tile Package": fileProcessor,
-        "Toolbox Package": fileProcessor,
-        "Vector Tile Package": fileProcessor,
-        "Viewer Configuration": fileProcessor,
-        "Visio Document": fileProcessor,
-        "Window Mobile Package": fileProcessor,
-        "Windows Mobile Package": fileProcessor,
-        "Windows Viewer Add In": fileProcessor,
-        "Windows Viewer Configuration": fileProcessor,
-        "Workflow Manager Package": fileProcessor,
-        ////////////////////////////////////////////////////////
-        // Testing "types"
-        Undefined: undefined,
-        Unsupported: UNSUPPORTED
-    };
+  /** @license
+   * Copyright 2018 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  const UNSUPPORTED$1 = null;
+  // ------------------------------------------------------------------------------------------------------------------ //
+  /**
+   * Deploys a set of items defined by templates.
+   *
+   * @param portalSharingUrl Server/sharing
+   * @param storageItemId Id of storage item
+   * @param templates A collection of AGO item templates
+   * @param storageAuthentication Credentials for the organization with the source items
+   * @param templateDictionary Hash of facts: org URL, adlib replacements
+   * @param deployedSolutionId Id of deployed Solution item
+   * @param destinationAuthentication Credentials for the destination organization
+   * @param options Options to tune deployment
+   * @return A promise that will resolve with the list of information about the created items
+   */
+  function deploySolutionItems(portalSharingUrl, storageItemId, templates, storageAuthentication, templateDictionary, deployedSolutionId, destinationAuthentication, options) {
+      return new Promise((resolve, reject) => {
+          // Prepare feedback mechanism
+          const totalEstimatedCost = _estimateDeploymentCost(templates) + 1; // solution items, plus avoid divide by 0
+          let percentDone = 10; // allow for previous deployment work
+          const progressPercentStep = (99 - percentDone) / totalEstimatedCost; // leave some % for caller for wrapup
+          const failedTemplateItemIds = [];
+          const deployedItemIds = [];
+          let statusOK = true;
+          // TODO: move to separate fn
+          const itemProgressCallback = (itemId, status, costUsed, createdItemId // supplied when status is EItemProgressStatus.Created or .Finished
+          ) => {
+              percentDone += progressPercentStep * costUsed;
+              /* istanbul ignore else */
+              if (options.progressCallback) {
+                  if (status === common.EItemProgressStatus.Finished) {
+                      const event = {
+                          event: common.SItemProgressStatus[status],
+                          data: itemId
+                      };
+                      options.progressCallback(Math.round(percentDone), options.jobId, event);
+                  }
+                  else {
+                      options.progressCallback(Math.round(percentDone), options.jobId);
+                  }
+              }
+              /* istanbul ignore if */
+              if (options.consoleProgress) {
+                  console.log(Date.now(), itemId, options.jobId ?? "", common.SItemProgressStatus[status], percentDone.toFixed(0) + "%", costUsed, createdItemId ? "==> " + createdItemId : "");
+              }
+              if (status === common.EItemProgressStatus.Created) {
+                  deployedItemIds.push(createdItemId);
+              }
+              else if (status === common.EItemProgressStatus.Failed) {
+                  failedTemplateItemIds.push(itemId);
+                  console.error("Item " + itemId + " has failed");
+                  statusOK = false;
+              }
+              return statusOK;
+              // ---------------------------------------------------------------------------------------------------------------
+          };
+          // portal does not allow views of a single source to be created at the same time
+          if (common.getProp(templateDictionary, "organization.isPortal")) {
+              templates = _evaluateSharedViewSources(templates);
+          }
+          // Create an ordered graph of the templates so that dependencies are created before the items that need them.
+          // Because cycles are permitted, we also keep track of items that need to be patched later because their
+          // dependencies are necessarily created after they are created.
+          const { buildOrder, itemsToBePatched } = common.topologicallySortItems(templates);
+          // For each item in order from no dependencies to dependent on other items,
+          //   * replace template symbols using template dictionary
+          //   * create item in destination group
+          //   * add created item's id into the template dictionary
+          const awaitAllItems = [];
+          const reuseItemsDef = _reuseDeployedItems(templates, options.enableItemReuse ?? false, templateDictionary, destinationAuthentication);
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+          reuseItemsDef.then(() => {
+              const useExistingItemsDef = _useExistingItems(templates, common.getProp(templateDictionary, "params.useExisting"), templateDictionary, destinationAuthentication);
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
+              useExistingItemsDef.then(() => {
+                  templates = common.setNamesAndTitles(templates, templateDictionary.solutionItemId);
+                  buildOrder.forEach((id) => {
+                      // Get the item's template out of the list of templates
+                      const template = common.findTemplateInList(templates, id);
+                      awaitAllItems.push(_createItemFromTemplateWhenReady(template, common.generateStorageFilePaths(portalSharingUrl, storageItemId, template.resources, options.storageVersion), storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback));
+                  });
+                  // Wait until all items have been created
+                  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                  Promise.all(awaitAllItems).then((clonedSolutionItems) => {
+                      if (failedTemplateItemIds.length === 0) {
+                          // Do we have any items to be patched (i.e., they refer to dependencies using the template id rather
+                          // than the cloned id because the item had to be created before the dependency)? Flag these items
+                          // for post processing in the list of clones.
+                          _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, clonedSolutionItems);
+                          resolve(clonedSolutionItems);
+                      }
+                      else {
+                          // Delete created items
+                          const progressOptions = {
+                              consoleProgress: true
+                          };
+                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                          common.deleteSolutionByComponents(deployedSolutionId, deployedItemIds, templates, templateDictionary, destinationAuthentication, progressOptions)
+                              .then(() => reject(common.failWithIds(failedTemplateItemIds)));
+                      }
+                  });
+              });
+          }, e => {
+              console.error(e);
+              reject(common.fail(e));
+          });
+      });
+  }
+  /**
+   * For each item to be patched, convert it to its cloned id and mark the item as needing post processing.
+   *
+   * @param itemsToBePatched List of items that need to have their dependencies patched
+   * @param templateDictionary Hash of facts: org URL, adlib replacements
+   * @param templates A collection of AGO item templates
+   */
+  function _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, templates) {
+      let itemIdsToBePatched = Object.keys(itemsToBePatched);
+      /* istanbul ignore else */
+      if (itemIdsToBePatched.length > 0) {
+          // Replace the ids of the items to be patched (which are template ids) with their cloned versions
+          itemIdsToBePatched = itemIdsToBePatched.map(id => templateDictionary[id].itemId);
+          // Make sure that the items to be patched are flagged for post processing
+          templates.forEach(item => {
+              /* istanbul ignore else */
+              if (itemIdsToBePatched.includes(item.id)) {
+                  item.postProcess = true;
+              }
+          });
+      }
+  }
+  /**
+   * Portal does not allow views of a single source to be created at the same time.
+   *
+   * Update view templates with an array of other view template ids that it should wait on.
+   *
+   * @param templates a collection of AGO item templates
+   *
+   * @returns An updated array of item templates
+   *
+   */
+  function _evaluateSharedViewSources(templates) {
+      // update the templates so we can defer the deployment when more than one view shares the same source
+      // these are not classic dependencies but are in some ways similar
+      const views = _getViews(templates);
+      _updateViewTemplates(templates, views);
+      const viewHash = _getViewHash(views);
+      let processed = [];
+      const visited = [];
+      Object.keys(viewHash).forEach(k => {
+          const _views = viewHash[k];
+          _views.forEach(cv => {
+              const template = common.findTemplateInList(templates, cv);
+              const syncViews = common.getProp(template, "properties.syncViews");
+              /* istanbul ignore else */
+              if (visited.indexOf(template.itemId) > -1) {
+                  processed = processed.concat(syncViews);
+              }
+              /* istanbul ignore else */
+              if (syncViews && syncViews.length > 0) {
+                  // when a view has multiple dependencies we need to retain the syncViews if they have been set already...
+                  common.setProp(template, "properties.syncViews", common.cloneObject(processed));
+              }
+              /* istanbul ignore else */
+              if (processed.indexOf(cv) < 0) {
+                  processed.push(cv);
+              }
+              /* istanbul ignore else */
+              if (visited.indexOf(template.itemId) < 0) {
+                  visited.push(template.itemId);
+              }
+          });
+          processed = [];
+      });
+      return templates;
+  }
+  /**
+   * Add a syncViews array to each template that will hold all other view ids that
+   * have the same FS dependency.
+   * These arrays will be processed later to only contain ids that each view will need to wait on.
+   *
+   * @param templates a collection of AGO item templates
+   * @param views an array of view template details
+   *
+   * @returns An updated array of item templates
+   *
+   */
+  function _updateViewTemplates(templates, views) {
+      views.forEach(v => {
+          v.dependencies.forEach((id) => {
+              templates = templates.map(t => {
+                  /* istanbul ignore else */
+                  if (common.getProp(t, "properties.service.isView") &&
+                      t.dependencies.indexOf(id) > -1 &&
+                      t.itemId !== v.id) {
+                      /* istanbul ignore else */
+                      if (!Array.isArray(t.properties.syncViews)) {
+                          t.properties.syncViews = [];
+                      }
+                      /* istanbul ignore else */
+                      if (t.properties.syncViews.indexOf(v.id) < 0) {
+                          t.properties.syncViews.push(v.id);
+                      }
+                  }
+                  return t;
+              });
+          });
+      });
+      return templates;
+  }
+  /**
+   * Get all view templates from the source templates collection
+   *
+   * @param views A collection of view ID and dependencies
+   *
+   * @returns an array of objects with the source FS id as the key and a list of views that are
+   * dependant upon it
+   *
+   * @protected
+   */
+  function _getViewHash(views) {
+      const viewHash = {};
+      views.forEach(v => {
+          v.dependencies.forEach((d) => {
+              /* istanbul ignore else */
+              if (Object.keys(viewHash).indexOf(d) < 0) {
+                  viewHash[d] = [v.id];
+              }
+              else if (viewHash[d].indexOf(v.id) < 0) {
+                  viewHash[d].push(v.id);
+              }
+          });
+      });
+      return viewHash;
+  }
+  /**
+   * Get all view templates from the source templates collection
+   *
+   * @param templates A collection of AGO item templates
+   *
+   * @returns an array with the view id and its dependencies
+   *
+   * @protected
+   */
+  function _getViews(templates) {
+      return templates.reduce((acc, v) => {
+          /* istanbul ignore else */
+          if (common.getProp(v, "properties.service.isView")) {
+              acc.push({
+                  id: v.itemId,
+                  dependencies: v.dependencies
+              });
+          }
+          return acc;
+      }, []);
+  }
+  /**
+   * Search for existing items and update the templateDictionary with key details
+   *
+   * @param templates A collection of AGO item templates
+   * @param reuseItems Option to search for existing items
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   * @param authentication Credentials for the requests
+   *
+   * @returns A Promise that will resolve once existing items have been evaluated
+   *
+   * @protected
+   */
+  function _reuseDeployedItems(templates, reuseItems, templateDictionary, authentication) {
+      return new Promise((resolve, reject) => {
+          if (reuseItems) {
+              const existingItemsByKeyword = _findExistingItemByKeyword(templates, templateDictionary, authentication);
+              Promise.all(existingItemsByKeyword).then((existingItemsByKeywordResponse) => {
+                  const existingItemsByTag = _handleExistingItems(existingItemsByKeywordResponse, templateDictionary, authentication, true);
+                  Promise.all(existingItemsByTag).then(existingItemsByTagResponse => {
+                      _handleExistingItems(existingItemsByTagResponse, templateDictionary, authentication, false);
+                      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                      _updateTemplateDictionary(templates, templateDictionary, authentication).then(resolve);
+                  }, e => reject(common.fail(e)));
+              }, e => reject(common.fail(e)));
+          }
+          else {
+              resolve(null);
+          }
+      });
+  }
+  /**
+   * Search for existing items and update the templateDictionary with key details
+   *
+   * Subtle difference between _reuseDeployedItems and _useExistingItems
+   * _reuseDeployedItems: will search all existing items based on specific type keywords
+   *   that would have been added by a previous deployment
+   * _useExistingItems: will search for an existing item that the user provided
+   *   the item id for while configuring in the deployment app.
+   *   This type of item would not necessarily have been laid down by a previous deployment and
+   *   can thus not expect that it will have the type keywords
+   *
+   * @param templates A collection of AGO item templates
+   * @param useExisting Option to search for existing items
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   * @param authentication Credentials for the requests
+   *
+   * @returns A Promise that will resolve once existing items have been evaluated
+   *
+   * @protected
+   */
+  function _useExistingItems(templates, useExisting, templateDictionary, authentication) {
+      return new Promise(resolve => {
+          if (useExisting) {
+              const itemDefs = [];
+              const sourceIdHash = {};
+              const itemIds = [];
+              Object.keys(templateDictionary.params).forEach(k => {
+                  const v = templateDictionary.params[k];
+                  /* istanbul ignore else */
+                  if (v.itemId && /[0-9A-F]{32}/i.test(k)) {
+                      _updateTemplateDictionaryById(templateDictionary, k, v.itemId, v);
+                      // need to check and set the typeKeyword if it doesn't exist on this service yet
+                      // when the user has passed in an itemId that does not come from a previous deployment
+                      itemDefs.push(common.getItemBase(v.itemId, authentication));
+                      sourceIdHash[v.itemId] = k;
+                      /* istanbul ignore else */
+                      if (itemIds.indexOf(k) < 0) {
+                          itemIds.push(k);
+                      }
+                  }
+              });
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
+              _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication).then(() => {
+                  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                  _updateTemplateDictionary(itemIds.map(id => common.getTemplateById(templates, id)), templateDictionary, authentication).then(resolve);
+              });
+          }
+          else {
+              resolve(null);
+          }
+      });
+  }
+  /**
+   * Verify if the existing item has the source-<itemId> typeKeyword and set it if not
+   * This allows items that did not come from deployment to be found for reuse after they
+   * have been used once via a custom itemId param
+   *
+   * @param itemDefs
+   * @param sourceIdHash key value pairs..actual itemId is the key and the source itemId is the value
+   * @param authentication credentials for the requests
+   *
+   * @return a promise to indicate when the requests are complete
+   */
+  function _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication) {
+      return new Promise(resolve => {
+          if (itemDefs.length > 0) {
+              Promise.all(itemDefs).then(results => {
+                  const itemUpdateDefs = [];
+                  results.forEach(result => {
+                      const sourceId = sourceIdHash[result.id];
+                      /* istanbul ignore else */
+                      if (result && sourceId && result.typeKeywords) {
+                          const sourceKeyword = `source-${sourceId}`;
+                          const typeKeywords = result.typeKeywords;
+                          /* istanbul ignore else */
+                          if (typeKeywords.indexOf(sourceKeyword) < 0) {
+                              typeKeywords.push(sourceKeyword);
+                              const itemUpdate = { id: result.id, typeKeywords };
+                              itemUpdateDefs.push(common.updateItem(itemUpdate, authentication));
+                          }
+                      }
+                  });
+                  // wait for updates to finish before we resolve
+                  if (itemUpdateDefs.length > 0) {
+                      Promise.all(itemUpdateDefs).then(resolve, () => resolve(undefined));
+                  }
+                  else {
+                      resolve(undefined);
+                  }
+              }, () => resolve(undefined));
+          }
+          else {
+              resolve(undefined);
+          }
+      });
+  }
+  /**
+   * Update the templateDictionary with key details by item type
+   *
+   * @param templates A collection of AGO item templates
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   *
+   * @protected
+   */
+  function _updateTemplateDictionary(templates, templateDictionary, authentication) {
+      return new Promise(resolve => {
+          const defs = [];
+          const urls = [];
+          const types = [];
+          const ids = [];
+          templates.forEach(t => {
+              const templateInfo = templateDictionary[t.itemId];
+              /* istanbul ignore else */
+              if (templateInfo && templateInfo.url && templateInfo.itemId) {
+                  /* istanbul ignore else */
+                  if (t.item.type === "Feature Service") {
+                      const enterpriseIDMapping = common.getProp(templateDictionary, `params.${t.itemId}.enterpriseIDMapping`);
+                      Object.assign(templateDictionary[t.itemId], common.getLayerSettings(common.getLayersAndTables(t), templateInfo.url, templateInfo.itemId, enterpriseIDMapping));
+                      // if the service has veiws keep track of the fields so we can use them to
+                      // compare with the view fields
+                      /* istanbul ignore else */
+                      if (common.getProp(t, "properties.service.hasViews")) {
+                          common._updateTemplateDictionaryFields(t, templateDictionary, false);
+                      }
+                  }
+                  // for fs query with its url...for non fs query the item
+                  // this is to verify situations where we have a stale search index that will
+                  // say some items exist when they don't really exist
+                  // searching the services url or with the item id will return an error when this condition occurs
+                  /* istanbul ignore else */
+                  if (urls.indexOf(templateInfo.url) < 0) {
+                      defs.push(t.item.type === "Feature Service"
+                          ? common.rest_request(templateInfo.url, { authentication })
+                          : common.getItemBase(templateInfo.itemId, authentication));
+                      urls.push(templateInfo.url);
+                      types.push(t.item.type);
+                      ids.push(templateInfo.itemId);
+                  }
+              }
+          });
+          if (defs.length > 0) {
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
+              Promise.all(defs.map(p => p.catch(e => e))).then(results => {
+                  /* istanbul ignore else */
+                  if (Array.isArray(results) && results.length > 0) {
+                      const fieldDefs = [];
+                      results.forEach((r, i) => {
+                          // a feature service result will contain a serviceItemId if it was successfully fetched
+                          if (r.serviceItemId && types[i] === "Feature Service") {
+                              Object.keys(templateDictionary).forEach(k => {
+                                  const v = templateDictionary[k];
+                                  /* istanbul ignore else */
+                                  if (v.itemId && v.itemId === r.serviceItemId) {
+                                      common.setDefaultSpatialReference(templateDictionary, k, r.spatialReference);
+                                      // keep the extent values from these responses as well
+                                      common.setCreateProp(templateDictionary, `${k}.defaultExtent`, r.fullExtent || r.initialExtent);
+                                      const layerIds = (r.layers || []).map((l) => l.id);
+                                      const tablesIds = (r.tables || []).map((t) => t.id);
+                                      fieldDefs.push(common.getExistingLayersAndTables(urls[i], layerIds.concat(tablesIds), authentication));
+                                  }
+                              });
+                          }
+                          else {
+                              /* istanbul ignore else */
+                              if (types[i] === "Feature Service" ||
+                                  common.getProp(r, "response.error")) {
+                                  // if an error is returned we need to clean up the templateDictionary
+                                  templateDictionary = _updateTemplateDictionaryForError(templateDictionary, ids[i]);
+                              }
+                          }
+                      });
+                      if (fieldDefs.length > 0) {
+                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                          Promise.all(fieldDefs).then(layerTableResult => {
+                              layerTableResult.forEach(l => {
+                                  l.forEach((ll) => {
+                                      Object.keys(templateDictionary).forEach(k => {
+                                          /* istanbul ignore else */
+                                          if (templateDictionary[k].itemId === ll.serviceItemId) {
+                                              let sourceId = "";
+                                              Object.keys(templateDictionary).some(_k => {
+                                                  /* istanbul ignore else */
+                                                  if (templateDictionary[_k].itemId === ll.serviceItemId) {
+                                                      sourceId = _k;
+                                                      return true;
+                                                  }
+                                              });
+                                              const enterpriseIDMapping = common.getProp(templateDictionary, `params.${sourceId}.enterpriseIDMapping`);
+                                              if (enterpriseIDMapping) {
+                                                  Object.keys(enterpriseIDMapping).forEach(id => {
+                                                      if (enterpriseIDMapping[id].toString() ===
+                                                          ll.id.toString()) {
+                                                          _setFields(templateDictionary, k, id, ll.fields);
+                                                      }
+                                                  });
+                                              }
+                                              else {
+                                                  _setFields(templateDictionary, k, ll.id, ll.fields);
+                                              }
+                                          }
+                                      });
+                                  });
+                              });
+                              resolve(null);
+                          });
+                      }
+                      else {
+                          resolve(null);
+                      }
+                  }
+                  else {
+                      resolve(null);
+                  }
+              });
+          }
+          else {
+              resolve(null);
+          }
+      });
+  }
+  /**
+   * Add the fields from the source layer to the template dictionary for any required replacements
+   *
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   * @param itemId the id for the item
+   * @param layerId the id for the layer
+   * @param fields the fields to transfer
+   *
+   * @protected
+   */
+  function _setFields(templateDictionary, itemId, layerId, fields) {
+      const layerInfo = common.getProp(templateDictionary, `${itemId}.layer${layerId}`);
+      /* istanbul ignore else */
+      if (layerInfo && fields) {
+          layerInfo.fields = fields;
+      }
+  }
+  /**
+   * In some cases an item id search will return a stale item reference
+   * it will subsequently fail when we try to fetch the underlying service.
+   *
+   * We need to remove the item info that has been added to the template dictionary
+   * and treat the item as we do other items that don't already exist on deployment.
+   *
+   * @param result the service request result
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   *
+   * @protected
+   */
+  function _updateTemplateDictionaryForError(templateDictionary, itemId) {
+      /* istanbul ignore else */
+      if (itemId) {
+          let removeKey = "";
+          Object.keys(templateDictionary).some(k => {
+              /* istanbul ignore else */
+              if (templateDictionary[k].itemId === itemId) {
+                  removeKey = k;
+                  return true;
+              }
+          });
+          /* istanbul ignore else */
+          if (removeKey !== "") {
+              delete templateDictionary[removeKey];
+          }
+      }
+      return templateDictionary;
+  }
+  /**
+   * Optionally search by tags and then update the templateDictionary based on the search results
+   *
+   * @param existingItemsResponse response object from search by typeKeyword and type
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   * @param authentication Credentials for the request
+   * @param addTagQuery Boolean to indicate if a search by tag should happen
+   * @return A promise that will resolve with an array of results
+   * @protected
+   */
+  function _handleExistingItems(existingItemsResponse, templateDictionary, authentication, addTagQuery) {
+      // if items are not found by type keyword search by tag
+      const existingItemsByTag = [Promise.resolve(null)];
+      /* istanbul ignore else */
+      if (existingItemsResponse && Array.isArray(existingItemsResponse)) {
+          existingItemsResponse.forEach(existingItem => {
+              /* istanbul ignore else */
+              if (Array.isArray(existingItem?.results)) {
+                  let result;
+                  const results = existingItem.results;
+                  if (results.length === 1) {
+                      result = results[0];
+                  }
+                  else if (results.length > 1) {
+                      result = results.reduce((a, b) => a.created > b.created ? a : b);
+                  }
+                  else {
+                      if (addTagQuery && existingItem.query) {
+                          const tagQuery = existingItem.query.replace("typekeywords", "tags");
+                          existingItemsByTag.push(_findExistingItem(tagQuery, authentication));
+                      }
+                  }
+                  if (result) {
+                      const sourceId = existingItem.query
+                          ? existingItem.query.match(/[0-9A-F]{32}/i)[0]
+                          : existingItem.sourceId;
+                      /* istanbul ignore else */
+                      if (sourceId) {
+                          _updateTemplateDictionaryById(templateDictionary, sourceId, result.id, result);
+                      }
+                  }
+              }
+          });
+      }
+      return existingItemsByTag;
+  }
+  function _updateTemplateDictionaryById(templateDictionary, sourceId, itemId, v) {
+      templateDictionary[sourceId] = Object.assign(templateDictionary[sourceId] || {}, {
+          def: Promise.resolve(common.generateEmptyCreationResponse(v.type, itemId)),
+          itemId,
+          name: v.name,
+          title: v.title,
+          url: v.url
+      });
+  }
+  /**
+   * Search items based on user query
+   *
+   * @param query Query string to use
+   * @param authentication Credentials for the request
+   * @return A promise that will resolve with an array of results
+   * @protected
+   */
+  function _findExistingItemByKeyword(templates, templateDictionary, authentication) {
+      const existingItemsDefs = [];
+      templates.forEach(template => {
+          if (template.item.type === "Group") {
+              const userGroups = templateDictionary.user?.groups;
+              /* istanbul ignore else */
+              if (Array.isArray(userGroups)) {
+                  existingItemsDefs.push(Promise.resolve({
+                      results: userGroups
+                          .filter(g => g.tags.indexOf(`source-${template.itemId}`) > -1)
+                          .map(g => {
+                          g.type = "Group";
+                          return g;
+                      }),
+                      sourceId: template.itemId
+                  }));
+              }
+          }
+          else {
+              existingItemsDefs.push(_findExistingItem(`typekeywords:source-${template.itemId} type:${template.item.type} owner:${templateDictionary.user.username}`, authentication));
+          }
+      });
+      return existingItemsDefs;
+  }
+  /**
+   * Search items based on user query
+   *
+   * @param query Query string to use
+   * @param authentication Credentials for the request
+   * @return A promise that will resolve with an array of results
+   * @protected
+   */
+  function _findExistingItem(query, authentication) {
+      const searchOptions = {
+          q: query,
+          authentication: authentication,
+          pagingParam: { start: 1, num: 100 }
+      };
+      return common.searchItems(searchOptions);
+  }
+  /**
+   * Creates an item from a template once the item's dependencies have been created.
+   *
+   * @param template Template of item to deploy
+   * @param resourceFilePaths URL, folder, and filename for each item resource/metadata/thumbnail
+   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
+   * @param userSession Options for the request
+   * @param itemProgressCallback Function for reporting progress updates from type-specific template handlers
+   * @return A promise that will resolve with the id of the deployed item (which is simply returned if it's
+   *         already in the templates list
+   * @protected
+   */
+  function _createItemFromTemplateWhenReady(template, resourceFilePaths, storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback) {
+      // ensure this is present
+      template.dependencies = template.dependencies || [];
+      // if there is no entry in the templateDictionary
+      // or if we have a basic entry without the deferred request for its creation, add it
+      if (!templateDictionary.hasOwnProperty(template.itemId) ||
+          !common.getProp(templateDictionary[template.itemId], "def")) {
+          let createResponse;
+          let statusCode = common.EItemProgressStatus.Unknown;
+          let itemHandler;
+          templateDictionary[template.itemId] =
+              templateDictionary[template.itemId] || {};
+          // Save the deferred for the use of items that depend on this item being created first
+          templateDictionary[template.itemId].def = new Promise(resolve => {
+              // Wait until all of the item's dependencies are deployed
+              const _awaitDependencies = template.dependencies.reduce((acc, id) => {
+                  const def = common.getProp(templateDictionary, `${id}.def`);
+                  // can't use maybePush as that clones the object, which does not work for Promises
+                  /* istanbul ignore else */
+                  if (def) {
+                      acc.push(def);
+                  }
+                  return acc;
+              }, []);
+              const syncViews = common.getProp(template, "properties.syncViews");
+              const awaitDependencies = syncViews && syncViews.length > 0
+                  ? syncViews.reduce((acc, v) => {
+                      const def = common.getProp(templateDictionary, `${v}.def`);
+                      /* istanbul ignore else */
+                      if (def) {
+                          acc.push(def);
+                      }
+                      return acc;
+                  }, _awaitDependencies)
+                  : _awaitDependencies;
+              Promise.all(awaitDependencies)
+                  .then(() => {
+                  // Find the conversion handler for this item type
+                  const templateType = template.type;
+                  itemHandler = moduleMap[templateType];
+                  if (!itemHandler || itemHandler === UNSUPPORTED$1) {
+                      if (itemHandler === UNSUPPORTED$1) {
+                          statusCode = common.EItemProgressStatus.Ignored;
+                          throw new Error();
+                      }
+                      else {
+                          statusCode = common.EItemProgressStatus.Failed;
+                          throw new Error();
+                      }
+                  }
+                  // Get the item's thumbnail
+                  return common.getThumbnailFromStorageItem(storageAuthentication, resourceFilePaths);
+              })
+                  .then(thumbnail => {
+                  template.item.thumbnail = thumbnail;
+                  // Delegate the creation of the item to the handler
+                  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                  return itemHandler.createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
+              })
+                  .then((response) => {
+                  if (response.id === "") {
+                      statusCode = common.EItemProgressStatus.Failed;
+                      throw new Error("handled"); // fails to create item
+                  }
+                  /* istanbul ignore else */
+                  createResponse = response;
+                  if (createResponse.item.item.url) {
+                      common.setCreateProp(templateDictionary, template.itemId + ".url", createResponse.item.item.url);
+                  }
+                  if (resourceFilePaths.length > 0) {
+                      // Copy resources, metadata, form
+                      return common.copyFilesFromStorageItem(storageAuthentication, resourceFilePaths, templateDictionary.folderId, createResponse.id, destinationAuthentication, createResponse.item);
+                  }
+                  else {
+                      return Promise.resolve(null);
+                  }
+              })
+                  .then(() => {
+                  resolve(createResponse);
+              })
+                  .catch(error => {
+                  if (!error || error.message !== "handled") {
+                      itemProgressCallback(template.itemId, statusCode === common.EItemProgressStatus.Unknown
+                          ? common.EItemProgressStatus.Failed
+                          : statusCode, 0);
+                  }
+                  // Item type not supported or fails to get item dependencies
+                  resolve(common.generateEmptyCreationResponse(template.type));
+              });
+          });
+      }
+      return templateDictionary[template.itemId].def;
+  }
+  /**
+   * Accumulates the estimated deployment cost of a set of templates.
+   *
+   * @param templates Templates to examine
+   * @return Sum of estimated deployment costs
+   * @protected
+   */
+  function _estimateDeploymentCost(templates) {
+      return templates.reduce((accumulatedEstimatedCost, template) => {
+          return (accumulatedEstimatedCost + (template.estimatedDeploymentCostFactor || 1));
+      }, 0);
+  }
+  // TODO: Return a Promise vs array of promises
+  function _getGroupUpdates(template, authentication, templateDictionary) {
+      const groups = template.groups || [];
+      return groups.map((sourceGroupId) => {
+          return common.shareItem(templateDictionary[sourceGroupId].itemId, template.itemId, authentication, common.isTrackingViewTemplate(template) ? templateDictionary.locationTracking.owner : undefined);
+      });
+  }
 
-    /** @license
-     * Copyright 2018 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    var UNSUPPORTED$1 = null;
-    // ------------------------------------------------------------------------------------------------------------------ //
-    /**
-     * Deploys a set of items defined by templates.
-     *
-     * @param portalSharingUrl Server/sharing
-     * @param storageItemId Id of storage item
-     * @param templates A collection of AGO item templates
-     * @param storageAuthentication Credentials for the organization with the source items
-     * @param templateDictionary Hash of facts: org URL, adlib replacements
-     * @param destinationAuthentication Credentials for the destination organization
-     * @param options Options to tune deployment
-     * @return A promise that will resolve with the list of information about the created items
-     */
-    function deploySolutionItems(portalSharingUrl, storageItemId, templates, storageAuthentication, templateDictionary, destinationAuthentication, options) {
-        return new Promise(function (resolve, reject) {
-            var _a;
-            // Prepare feedback mechanism
-            var totalEstimatedCost = _estimateDeploymentCost(templates) + 1; // solution items, plus avoid divide by 0
-            var percentDone = 10; // allow for previous deployment work
-            var progressPercentStep = (99 - percentDone) / totalEstimatedCost; // leave some % for caller for wrapup
-            var failedTemplateItemIds = [];
-            var deployedItemIds = [];
-            var statusOK = true;
-            // TODO: move to separate fn
-            var itemProgressCallback = function (itemId, status, costUsed, createdItemId // supplied when status is EItemProgressStatus.Created or .Finished
-            ) {
-                var _a;
-                percentDone += progressPercentStep * costUsed;
-                /* istanbul ignore else */
-                if (options.progressCallback) {
-                    if (status === common.EItemProgressStatus.Finished) {
-                        var event_1 = {
-                            event: common.SItemProgressStatus[status],
-                            data: itemId
-                        };
-                        options.progressCallback(Math.round(percentDone), options.jobId, event_1);
-                    }
-                    else {
-                        options.progressCallback(Math.round(percentDone), options.jobId);
-                    }
-                }
-                /* istanbul ignore if */
-                if (options.consoleProgress) {
-                    console.log(Date.now(), itemId, (_a = options.jobId) !== null && _a !== void 0 ? _a : "", common.SItemProgressStatus[status], percentDone.toFixed(0) + "%", costUsed, createdItemId ? "==> " + createdItemId : "");
-                }
-                if (status === common.EItemProgressStatus.Created) {
-                    deployedItemIds.push(createdItemId);
-                }
-                else if (status === common.EItemProgressStatus.Failed) {
-                    failedTemplateItemIds.push(itemId);
-                    console.error("Item " + itemId + " has failed");
-                    statusOK = false;
-                }
-                return statusOK;
-                // ---------------------------------------------------------------------------------------------------------------
-            };
-            // portal does not allow views of a single source to be created at the same time
-            if (common.getProp(templateDictionary, "organization.isPortal")) {
-                templates = _evaluateSharedViewSources(templates);
-            }
-            // Create an ordered graph of the templates so that dependencies are created before the items that need them.
-            // Because cycles are permitted, we also keep track of items that need to be patched later because their
-            // dependencies are necessarily created after they are created.
-            var _b = common.topologicallySortItems(templates), buildOrder = _b.buildOrder, itemsToBePatched = _b.itemsToBePatched;
-            // For each item in order from no dependencies to dependent on other items,
-            //   * replace template symbols using template dictionary
-            //   * create item in destination group
-            //   * add created item's id into the template dictionary
-            var awaitAllItems = [];
-            var reuseItemsDef = _reuseDeployedItems(templates, (_a = options.enableItemReuse) !== null && _a !== void 0 ? _a : false, templateDictionary, destinationAuthentication);
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            reuseItemsDef.then(function () {
-                var useExistingItemsDef = _useExistingItems(templates, common.getProp(templateDictionary, "params.useExisting"), templateDictionary, destinationAuthentication);
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                useExistingItemsDef.then(function () {
-                    templates = common.setNamesAndTitles(templates, templateDictionary.solutionItemId);
-                    buildOrder.forEach(function (id) {
-                        // Get the item's template out of the list of templates
-                        var template = common.findTemplateInList(templates, id);
-                        awaitAllItems.push(_createItemFromTemplateWhenReady(template, common.generateStorageFilePaths(portalSharingUrl, storageItemId, template.resources, options.storageVersion), storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback));
-                    });
-                    // Wait until all items have been created
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    Promise.all(awaitAllItems).then(function (clonedSolutionItems) {
-                        if (failedTemplateItemIds.length === 0) {
-                            // Do we have any items to be patched (i.e., they refer to dependencies using the template id rather
-                            // than the cloned id because the item had to be created before the dependency)? Flag these items
-                            // for post processing in the list of clones.
-                            _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, clonedSolutionItems);
-                            resolve(clonedSolutionItems);
-                        }
-                        else {
-                            // Delete created items
-                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                            common.removeListOfItemsOrGroups(deployedItemIds, destinationAuthentication)
-                                .then(function () {
-                                return reject(common.failWithIds(failedTemplateItemIds));
-                            });
-                        }
-                    });
-                });
-            }, function (e) {
-                console.error(e);
-                reject(common.fail(e));
-            });
-        });
-    }
-    /**
-     * For each item to be patched, convert it to its cloned id and mark the item as needing post processing.
-     *
-     * @param itemsToBePatched List of items that need to have their dependencies patched
-     * @param templateDictionary Hash of facts: org URL, adlib replacements
-     * @param templates A collection of AGO item templates
-     */
-    function _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, templates) {
-        var itemIdsToBePatched = Object.keys(itemsToBePatched);
-        /* istanbul ignore else */
-        if (itemIdsToBePatched.length > 0) {
-            // Replace the ids of the items to be patched (which are template ids) with their cloned versions
-            itemIdsToBePatched = itemIdsToBePatched.map(function (id) { return templateDictionary[id].itemId; });
-            // Make sure that the items to be patched are flagged for post processing
-            templates.forEach(function (item) {
-                /* istanbul ignore else */
-                if (itemIdsToBePatched.includes(item.id)) {
-                    item.postProcess = true;
-                }
-            });
-        }
-    }
-    /**
-     * Portal does not allow views of a single source to be created at the same time.
-     *
-     * Update view templates with an array of other view template ids that it should wait on.
-     *
-     * @param templates a collection of AGO item templates
-     *
-     * @returns An updated array of item templates
-     *
-     */
-    function _evaluateSharedViewSources(templates) {
-        // update the templates so we can defer the deployment when more than one view shares the same source
-        // these are not classic dependencies but are in some ways similar
-        var views = _getViews(templates);
-        _updateViewTemplates(templates, views);
-        var viewHash = _getViewHash(views);
-        var processed = [];
-        var visited = [];
-        Object.keys(viewHash).forEach(function (k) {
-            var _views = viewHash[k];
-            _views.forEach(function (cv) {
-                var template = common.findTemplateInList(templates, cv);
-                var syncViews = common.getProp(template, "properties.syncViews");
-                /* istanbul ignore else */
-                if (visited.indexOf(template.itemId) > -1) {
-                    processed = processed.concat(syncViews);
-                }
-                /* istanbul ignore else */
-                if (syncViews && syncViews.length > 0) {
-                    // when a view has multiple dependencies we need to retain the syncViews if they have been set already...
-                    common.setProp(template, "properties.syncViews", common.cloneObject(processed));
-                }
-                /* istanbul ignore else */
-                if (processed.indexOf(cv) < 0) {
-                    processed.push(cv);
-                }
-                /* istanbul ignore else */
-                if (visited.indexOf(template.itemId) < 0) {
-                    visited.push(template.itemId);
-                }
-            });
-            processed = [];
-        });
-        return templates;
-    }
-    /**
-     * Add a syncViews array to each template that will hold all other view ids that
-     * have the same FS dependency.
-     * These arrays will be processed later to only contain ids that each view will need to wait on.
-     *
-     * @param templates a collection of AGO item templates
-     * @param views an array of view template details
-     *
-     * @returns An updated array of item templates
-     *
-     */
-    function _updateViewTemplates(templates, views) {
-        views.forEach(function (v) {
-            v.dependencies.forEach(function (id) {
-                templates = templates.map(function (t) {
-                    /* istanbul ignore else */
-                    if (common.getProp(t, "properties.service.isView") &&
-                        t.dependencies.indexOf(id) > -1 &&
-                        t.itemId !== v.id) {
-                        /* istanbul ignore else */
-                        if (!Array.isArray(t.properties.syncViews)) {
-                            t.properties.syncViews = [];
-                        }
-                        /* istanbul ignore else */
-                        if (t.properties.syncViews.indexOf(v.id) < 0) {
-                            t.properties.syncViews.push(v.id);
-                        }
-                    }
-                    return t;
-                });
-            });
-        });
-        return templates;
-    }
-    /**
-     * Get all view templates from the source templates collection
-     *
-     * @param views A collection of view ID and dependencies
-     *
-     * @returns an array of objects with the source FS id as the key and a list of views that are
-     * dependant upon it
-     *
-     * @protected
-     */
-    function _getViewHash(views) {
-        var viewHash = {};
-        views.forEach(function (v) {
-            v.dependencies.forEach(function (d) {
-                /* istanbul ignore else */
-                if (Object.keys(viewHash).indexOf(d) < 0) {
-                    viewHash[d] = [v.id];
-                }
-                else if (viewHash[d].indexOf(v.id) < 0) {
-                    viewHash[d].push(v.id);
-                }
-            });
-        });
-        return viewHash;
-    }
-    /**
-     * Get all view templates from the source templates collection
-     *
-     * @param templates A collection of AGO item templates
-     *
-     * @returns an array with the view id and its dependencies
-     *
-     * @protected
-     */
-    function _getViews(templates) {
-        return templates.reduce(function (acc, v) {
-            /* istanbul ignore else */
-            if (common.getProp(v, "properties.service.isView")) {
-                acc.push({
-                    id: v.itemId,
-                    dependencies: v.dependencies
-                });
-            }
-            return acc;
-        }, []);
-    }
-    /**
-     * Search for existing items and update the templateDictionary with key details
-     *
-     * @param templates A collection of AGO item templates
-     * @param reuseItems Option to search for existing items
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     * @param authentication Credentials for the requests
-     *
-     * @returns A Promise that will resolve once existing items have been evaluated
-     *
-     * @protected
-     */
-    function _reuseDeployedItems(templates, reuseItems, templateDictionary, authentication) {
-        return new Promise(function (resolve, reject) {
-            if (reuseItems) {
-                var existingItemsByKeyword = _findExistingItemByKeyword(templates, templateDictionary, authentication);
-                Promise.all(existingItemsByKeyword).then(function (existingItemsByKeywordResponse) {
-                    var existingItemsByTag = _handleExistingItems(existingItemsByKeywordResponse, templateDictionary, authentication, true);
-                    Promise.all(existingItemsByTag).then(function (existingItemsByTagResponse) {
-                        _handleExistingItems(existingItemsByTagResponse, templateDictionary, authentication, false);
-                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        _updateTemplateDictionary(templates, templateDictionary, authentication).then(resolve);
-                    }, function (e) { return reject(common.fail(e)); });
-                }, function (e) { return reject(common.fail(e)); });
-            }
-            else {
-                resolve(null);
-            }
-        });
-    }
-    /**
-     * Search for existing items and update the templateDictionary with key details
-     *
-     * Subtle difference between _reuseDeployedItems and _useExistingItems
-     * _reuseDeployedItems: will search all existing items based on specific type keywords
-     *   that would have been added by a previous deployment
-     * _useExistingItems: will search for an existing item that the user provided
-     *   the item id for while configuring in the deployment app.
-     *   This type of item would not necessarily have been laid down by a previous deployment and
-     *   can thus not expect that it will have the type keywords
-     *
-     * @param templates A collection of AGO item templates
-     * @param useExisting Option to search for existing items
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     * @param authentication Credentials for the requests
-     *
-     * @returns A Promise that will resolve once existing items have been evaluated
-     *
-     * @protected
-     */
-    function _useExistingItems(templates, useExisting, templateDictionary, authentication) {
-        return new Promise(function (resolve) {
-            if (useExisting) {
-                var itemIds_1 = [];
-                Object.keys(templateDictionary.params).forEach(function (k) {
-                    var v = templateDictionary.params[k];
-                    /* istanbul ignore else */
-                    if (v.itemId && v.sourceId) {
-                        _updateTemplateDictionaryById(templateDictionary, v.sourceId, v.itemId, v);
-                        /* istanbul ignore else */
-                        if (itemIds_1.indexOf(v.sourceId) < 0) {
-                            itemIds_1.push(v.sourceId);
-                        }
-                    }
-                });
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                _updateTemplateDictionary(itemIds_1.map(function (id) { return common.getTemplateById(templates, id); }), templateDictionary, authentication).then(resolve);
-            }
-            else {
-                resolve(null);
-            }
-        });
-    }
-    /**
-     * Update the templateDictionary with key details by item type
-     *
-     * @param templates A collection of AGO item templates
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     *
-     * @protected
-     */
-    function _updateTemplateDictionary(templates, templateDictionary, authentication) {
-        return new Promise(function (resolve) {
-            var defs = [];
-            var urls = [];
-            var types = [];
-            var ids = [];
-            templates.forEach(function (t) {
-                var templateInfo = templateDictionary[t.itemId];
-                /* istanbul ignore else */
-                if (templateInfo && templateInfo.url && templateInfo.itemId) {
-                    /* istanbul ignore else */
-                    if (t.item.type === "Feature Service") {
-                        Object.assign(templateDictionary[t.itemId], common.getLayerSettings(common.getLayersAndTables(t), templateInfo.url, templateInfo.itemId));
-                        // if the service has veiws keep track of the fields so we can use them to
-                        // compare with the view fields
-                        /* istanbul ignore else */
-                        if (common.getProp(t, "properties.service.hasViews")) {
-                            common._updateTemplateDictionaryFields(t, templateDictionary, false);
-                        }
-                    }
-                    // for fs query with its url...for non fs query the item
-                    // this is to verify situations where we have a stale search index that will
-                    // say some items exist when they don't really exist
-                    // searching the services url or with the item id will return an error when this condition occurs
-                    /* istanbul ignore else */
-                    if (urls.indexOf(templateInfo.url) < 0) {
-                        defs.push(t.item.type === "Feature Service"
-                            ? common.rest_request(templateInfo.url, { authentication: authentication })
-                            : common.getItemBase(templateInfo.itemId, authentication));
-                        urls.push(templateInfo.url);
-                        types.push(t.item.type);
-                        ids.push(templateInfo.itemId);
-                    }
-                }
-            });
-            if (defs.length > 0) {
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.all(defs.map(function (p) { return p.catch(function (e) { return e; }); })).then(function (results) {
-                    /* istanbul ignore else */
-                    if (Array.isArray(results) && results.length > 0) {
-                        var fieldDefs_1 = [];
-                        results.forEach(function (r, i) {
-                            // a feature service result will contain a serviceItemId if it was successfully fetched
-                            if (r.serviceItemId && types[i] === "Feature Service") {
-                                Object.keys(templateDictionary).forEach(function (k) {
-                                    var v = templateDictionary[k];
-                                    /* istanbul ignore else */
-                                    if (v.itemId && v.itemId === r.serviceItemId) {
-                                        common.setDefaultSpatialReference(templateDictionary, k, r.spatialReference);
-                                        // keep the extent values from these responses as well
-                                        common.setCreateProp(templateDictionary, k + ".defaultExtent", r.fullExtent || r.initialExtent);
-                                        var layerIds = (r.layers || []).map(function (l) { return l.id; });
-                                        var tablesIds = (r.tables || []).map(function (t) { return t.id; });
-                                        fieldDefs_1.push(common.getExistingLayersAndTables(urls[i], layerIds.concat(tablesIds), authentication));
-                                    }
-                                });
-                            }
-                            else {
-                                /* istanbul ignore else */
-                                if (types[i] === "Feature Service" ||
-                                    common.getProp(r, "response.error")) {
-                                    // if an error is returned we need to clean up the templateDictionary
-                                    templateDictionary = _updateTemplateDictionaryForError(templateDictionary, ids[i]);
-                                }
-                            }
-                        });
-                        if (fieldDefs_1.length > 0) {
-                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                            Promise.all(fieldDefs_1).then(function (layerTableResult) {
-                                layerTableResult.forEach(function (l) {
-                                    l.forEach(function (ll) {
-                                        Object.keys(templateDictionary).forEach(function (k) {
-                                            /* istanbul ignore else */
-                                            if (templateDictionary[k].itemId === ll.serviceItemId) {
-                                                var layerInfo = common.getProp(templateDictionary, k + ".layer" + ll.id);
-                                                /* istanbul ignore else */
-                                                if (layerInfo && ll.fields) {
-                                                    layerInfo.fields = ll.fields;
-                                                }
-                                            }
-                                        });
-                                    });
-                                });
-                                resolve(null);
-                            });
-                        }
-                        else {
-                            resolve(null);
-                        }
-                    }
-                    else {
-                        resolve(null);
-                    }
-                });
-            }
-            else {
-                resolve(null);
-            }
-        });
-    }
-    /**
-     * In some cases an item id search will return a stale item reference
-     * it will subsequently fail when we try to fetch the underlying service.
-     *
-     * We need to remove the item info that has been added to the template dictionary
-     * and treat the item as we do other items that don't already exist on deployment.
-     *
-     * @param result the service request result
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     *
-     * @protected
-     */
-    function _updateTemplateDictionaryForError(templateDictionary, itemId) {
-        /* istanbul ignore else */
-        if (itemId) {
-            var removeKey_1 = "";
-            Object.keys(templateDictionary).some(function (k) {
-                /* istanbul ignore else */
-                if (templateDictionary[k].itemId === itemId) {
-                    removeKey_1 = k;
-                    return true;
-                }
-            });
-            /* istanbul ignore else */
-            if (removeKey_1 !== "") {
-                delete templateDictionary[removeKey_1];
-            }
-        }
-        return templateDictionary;
-    }
-    /**
-     * Optionally search by tags and then update the templateDictionary based on the search results
-     *
-     * @param existingItemsResponse response object from search by typeKeyword and type
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     * @param authentication Credentials for the request
-     * @param addTagQuery Boolean to indicate if a search by tag should happen
-     * @return A promise that will resolve with an array of results
-     * @protected
-     */
-    function _handleExistingItems(existingItemsResponse, templateDictionary, authentication, addTagQuery) {
-        // if items are not found by type keyword search by tag
-        var existingItemsByTag = [Promise.resolve(null)];
-        /* istanbul ignore else */
-        if (existingItemsResponse && Array.isArray(existingItemsResponse)) {
-            existingItemsResponse.forEach(function (existingItem) {
-                /* istanbul ignore else */
-                if (Array.isArray(existingItem === null || existingItem === void 0 ? void 0 : existingItem.results)) {
-                    var result = void 0;
-                    var results = existingItem.results;
-                    if (results.length === 1) {
-                        result = results[0];
-                    }
-                    else if (results.length > 1) {
-                        result = results.reduce(function (a, b) {
-                            return a.created > b.created ? a : b;
-                        });
-                    }
-                    else {
-                        if (addTagQuery && existingItem.query) {
-                            var tagQuery = existingItem.query.replace("typekeywords", "tags");
-                            existingItemsByTag.push(_findExistingItem(tagQuery, authentication));
-                        }
-                    }
-                    if (result) {
-                        var sourceId = existingItem.query
-                            ? existingItem.query.match(/[0-9A-F]{32}/i)[0]
-                            : existingItem.sourceId;
-                        /* istanbul ignore else */
-                        if (sourceId) {
-                            _updateTemplateDictionaryById(templateDictionary, sourceId, result.id, result);
-                        }
-                    }
-                }
-            });
-        }
-        return existingItemsByTag;
-    }
-    function _updateTemplateDictionaryById(templateDictionary, sourceId, itemId, v) {
-        templateDictionary[sourceId] = Object.assign(templateDictionary[sourceId] || {}, {
-            def: Promise.resolve(common.generateEmptyCreationResponse(v.type, itemId)),
-            itemId: itemId,
-            name: v.name,
-            title: v.title,
-            url: v.url
-        });
-    }
-    /**
-     * Search items based on user query
-     *
-     * @param query Query string to use
-     * @param authentication Credentials for the request
-     * @return A promise that will resolve with an array of results
-     * @protected
-     */
-    function _findExistingItemByKeyword(templates, templateDictionary, authentication) {
-        var existingItemsDefs = [];
-        templates.forEach(function (template) {
-            var _a;
-            if (template.item.type === "Group") {
-                var userGroups = (_a = templateDictionary.user) === null || _a === void 0 ? void 0 : _a.groups;
-                /* istanbul ignore else */
-                if (Array.isArray(userGroups)) {
-                    existingItemsDefs.push(Promise.resolve({
-                        results: userGroups
-                            .filter(function (g) { return g.tags.indexOf("source-" + template.itemId) > -1; })
-                            .map(function (g) {
-                            g.type = "Group";
-                            return g;
-                        }),
-                        sourceId: template.itemId
-                    }));
-                }
-            }
-            else {
-                existingItemsDefs.push(_findExistingItem("typekeywords:source-" + template.itemId + " type:" + template.item.type + " owner:" + templateDictionary.user.username, authentication));
-            }
-        });
-        return existingItemsDefs;
-    }
-    /**
-     * Search items based on user query
-     *
-     * @param query Query string to use
-     * @param authentication Credentials for the request
-     * @return A promise that will resolve with an array of results
-     * @protected
-     */
-    function _findExistingItem(query, authentication) {
-        var searchOptions = {
-            q: query,
-            authentication: authentication,
-            pagingParam: { start: 1, num: 100 }
-        };
-        return common.searchItems(searchOptions);
-    }
-    /**
-     * Creates an item from a template once the item's dependencies have been created.
-     *
-     * @param template Template of item to deploy
-     * @param resourceFilePaths URL, folder, and filename for each item resource/metadata/thumbnail
-     * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-     * @param userSession Options for the request
-     * @param itemProgressCallback Function for reporting progress updates from type-specific template handlers
-     * @return A promise that will resolve with the id of the deployed item (which is simply returned if it's
-     *         already in the templates list
-     * @protected
-     */
-    function _createItemFromTemplateWhenReady(template, resourceFilePaths, storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback) {
-        // ensure this is present
-        template.dependencies = template.dependencies || [];
-        // if there is no entry in the templateDictionary
-        // or if we have a basic entry without the deferred request for its creation, add it
-        if (!templateDictionary.hasOwnProperty(template.itemId) ||
-            !common.getProp(templateDictionary[template.itemId], "def")) {
-            var createResponse_1;
-            var statusCode_1 = common.EItemProgressStatus.Unknown;
-            var itemHandler_1;
-            templateDictionary[template.itemId] =
-                templateDictionary[template.itemId] || {};
-            // Save the deferred for the use of items that depend on this item being created first
-            templateDictionary[template.itemId].def = new Promise(function (resolve) {
-                // Wait until all of the item's dependencies are deployed
-                var _awaitDependencies = template.dependencies.reduce(function (acc, id) {
-                    var def = common.getProp(templateDictionary, id + ".def");
-                    // can't use maybePush as that clones the object, which does not work for Promises
-                    /* istanbul ignore else */
-                    if (def) {
-                        acc.push(def);
-                    }
-                    return acc;
-                }, []);
-                var syncViews = common.getProp(template, "properties.syncViews");
-                var awaitDependencies = syncViews && syncViews.length > 0
-                    ? syncViews.reduce(function (acc, v) {
-                        var def = common.getProp(templateDictionary, v + ".def");
-                        /* istanbul ignore else */
-                        if (def) {
-                            acc.push(def);
-                        }
-                        return acc;
-                    }, _awaitDependencies)
-                    : _awaitDependencies;
-                Promise.all(awaitDependencies)
-                    .then(function () {
-                    // Find the conversion handler for this item type
-                    var templateType = template.type;
-                    itemHandler_1 = moduleMap[templateType];
-                    if (!itemHandler_1 || itemHandler_1 === UNSUPPORTED$1) {
-                        if (itemHandler_1 === UNSUPPORTED$1) {
-                            statusCode_1 = common.EItemProgressStatus.Ignored;
-                            throw new Error();
-                        }
-                        else {
-                            statusCode_1 = common.EItemProgressStatus.Failed;
-                            throw new Error();
-                        }
-                    }
-                    // Get the item's thumbnail
-                    return common.getThumbnailFromStorageItem(storageAuthentication, resourceFilePaths);
-                })
-                    .then(function (thumbnail) {
-                    template.item.thumbnail = thumbnail;
-                    // Delegate the creation of the item to the handler
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    return itemHandler_1.createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
-                })
-                    .then(function (response) {
-                    if (response.id === "") {
-                        statusCode_1 = common.EItemProgressStatus.Failed;
-                        throw new Error("handled"); // fails to create item
-                    }
-                    /* istanbul ignore else */
-                    createResponse_1 = response;
-                    if (createResponse_1.item.item.url) {
-                        common.setCreateProp(templateDictionary, template.itemId + ".url", createResponse_1.item.item.url);
-                    }
-                    // Copy resources, metadata, form
-                    return common.copyFilesFromStorageItem(storageAuthentication, resourceFilePaths, templateDictionary.folderId, createResponse_1.id, destinationAuthentication, createResponse_1.item);
-                })
-                    .then(function () {
-                    resolve(createResponse_1);
-                })
-                    .catch(function (error) {
-                    if (!error || error.message !== "handled") {
-                        itemProgressCallback(template.itemId, statusCode_1 === common.EItemProgressStatus.Unknown
-                            ? common.EItemProgressStatus.Failed
-                            : statusCode_1, 0);
-                    }
-                    // Item type not supported or fails to get item dependencies
-                    resolve(common.generateEmptyCreationResponse(template.type));
-                });
-            });
-        }
-        return templateDictionary[template.itemId].def;
-    }
-    /**
-     * Accumulates the estimated deployment cost of a set of templates.
-     *
-     * @param templates Templates to examine
-     * @return Sum of estimated deployment costs
-     * @protected
-     */
-    function _estimateDeploymentCost(templates) {
-        return templates.reduce(function (accumulatedEstimatedCost, template) {
-            return (accumulatedEstimatedCost + (template.estimatedDeploymentCostFactor || 1));
-        }, 0);
-    }
-    // TODO: Return a Promise vs array of promises
-    function _getGroupUpdates(template, authentication, templateDictionary) {
-        var groups = template.groups || [];
-        return groups.map(function (sourceGroupId) {
-            return common.shareItem(templateDictionary[sourceGroupId].itemId, template.itemId, authentication);
-        });
-    }
+  /** @license
+   * Copyright 2020 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  /**
+   * Given the created templates
+   *
+   * @param templates
+   * @param templateDictionary
+   * @param authentication
+   */
+  function shareTemplatesToGroups(templates, templateDictionary, authentication) {
+      // Filter to entries with groups to share to
+      const templatesWithGroups = templates.filter(e => {
+          return e.groups && e.groups.length > 0;
+      });
+      // fire off all the promises
+      return Promise.all(templatesWithGroups.map(tmpl => {
+          const groupIds = tmpl.groups.reduce((acc, sourceGroupId) => {
+              return hubCommon.maybePush(common.getProp(templateDictionary, `${sourceGroupId}.itemId`), acc);
+          }, []);
+          // need to pass the tracking owner when sharing to tracking group
+          if (common.isTrackingViewTemplate(tmpl) && !common.getProp(templateDictionary, "locationTracking.userIsOwner")) {
+              const trackingGroupId = common.getProp(tmpl, "item.properties.trackViewGroup");
+              const owner = common.getProp(templateDictionary, "locationTracking.owner");
+              /* istanbul ignore else */
+              if (trackingGroupId && owner) {
+                  const trackerGroupIds = groupIds.filter(id => {
+                      return id === common.replaceInTemplate(trackingGroupId, templateDictionary);
+                  });
+                  if (trackerGroupIds.length !== groupIds.length) {
+                      const nonTrackerGroupIds = groupIds.filter(id => id !== trackingGroupId);
+                      return Promise.all([
+                          common.shareItemToGroups(trackerGroupIds, tmpl.itemId, authentication, owner),
+                          common.shareItemToGroups(nonTrackerGroupIds, tmpl.itemId, authentication)
+                      ]);
+                  }
+                  else {
+                      return common.shareItemToGroups(groupIds, tmpl.itemId, authentication, owner);
+                  }
+              }
+          }
+          else {
+              return common.shareItemToGroups(groupIds, tmpl.itemId, authentication);
+          }
+      }));
+  }
 
-    /** @license
-     * Copyright 2020 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    /**
-     * Given the created templates
-     *
-     * @param templates
-     * @param templateDictionary
-     * @param authentication
-     */
-    function shareTemplatesToGroups(templates, templateDictionary, authentication) {
-        // Filter to entries with groups to share to
-        var templatesWithGroups = templates.filter(function (e) {
-            return e.groups && e.groups.length > 0;
-        });
-        // fire off all the promises
-        return Promise.all(templatesWithGroups.map(function (tmpl) {
-            var groupIds = tmpl.groups.reduce(function (acc, sourceGroupId) {
-                return hubCommon.maybePush(common.getProp(templateDictionary, sourceGroupId + ".itemId"), acc);
-            }, []);
-            return common.shareItemToGroups(groupIds, tmpl.itemId, authentication);
-        }));
-    }
+  /** @license
+   * Copyright 2020 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  /**
+   * Delegate post-processing to the type specific
+   * processors. This allows each type to have fine-grained
+   * control over what they do. Common post-processing is
+   * exposed as functions that can be imported
+   *
+   * @param deployedSolutionId
+   * @param templates
+   * @param clonedSolutions
+   * @param authentication
+   * @param templateDictionary
+   */
+  function postProcess(deployedSolutionId, templates, clonedSolutions, authentication, templateDictionary) {
+      // connect the solution with its items; groups cannot be connected
+      const relationshipPromises = clonedSolutions
+          .filter(entry => entry.type !== "Group")
+          .map(entry => portal.addItemRelationship({
+          originItemId: deployedSolutionId,
+          destinationItemId: entry.id,
+          relationshipType: "Solution2Item",
+          authentication: authentication
+      }) // TODO: remove `as any`, which is here until arcgis-rest-js' ItemRelationshipType defn catches up
+      );
+      // delegate sharing to groups
+      const sharePromises = shareTemplatesToGroups(templates, templateDictionary, authentication);
+      // what needs post processing?
+      const itemsToProcess = clonedSolutions.filter(entry => entry.postProcess);
+      // map over these items
+      const postProcessPromises = itemsToProcess.reduce((acc, entry) => {
+          const itemHandler = moduleMap[entry.type];
+          // only delegate if the handler has a postProcess method
+          if (itemHandler && itemHandler.postProcess) {
+              acc.push(itemHandler.postProcess(entry.id, entry.type, clonedSolutions, common.getTemplateById(templates, entry.id), templates, templateDictionary, authentication));
+          }
+          return acc;
+      }, []);
+      return Promise.all([sharePromises].concat(postProcessPromises, relationshipPromises));
+  }
 
-    /**
-     * Delegate post-processing to the type specific
-     * processors. This allows each type to have fine-grained
-     * control over what they do. Common post-processing is
-     * exposed as functions that can be imported
-     *
-     * @param deployedSolutionId
-     * @param templates
-     * @param clonedSolutions
-     * @param authentication
-     * @param templateDictionary
-     */
-    function postProcess(deployedSolutionId, templates, clonedSolutions, authentication, templateDictionary) {
-        // connect the solution with its items; groups cannot be connected
-        var relationshipPromises = clonedSolutions
-            .filter(function (entry) { return entry.type !== "Group"; })
-            .map(function (entry) {
-            return arcgisRestPortal.addItemRelationship({
-                originItemId: deployedSolutionId,
-                destinationItemId: entry.id,
-                relationshipType: "Solution2Item",
-                authentication: authentication
-            });
-        } // TODO: remove `as any`, which is here until arcgis-rest-js' ItemRelationshipType defn catches up
-        );
-        // delegate sharing to groups
-        var sharePromises = shareTemplatesToGroups(templates, templateDictionary, authentication);
-        // what needs post processing?
-        var itemsToProcess = clonedSolutions.filter(function (entry) { return entry.postProcess; });
-        // map over these items
-        var postProcessPromises = itemsToProcess.reduce(function (acc, entry) {
-            var itemHandler = moduleMap[entry.type];
-            // only delegate if the handler has a postProcess method
-            if (itemHandler && itemHandler.postProcess) {
-                acc.push(itemHandler.postProcess(entry.id, entry.type, clonedSolutions, common.getTemplateById(templates, entry.id), templates, templateDictionary, authentication));
-            }
-            return acc;
-        }, []);
-        return Promise.all(__spread(postProcessPromises, [
-            sharePromises
-        ], relationshipPromises));
-    }
+  /**
+   * Sorts a list of templates in place to match a provided sort-order list.
+   *
+   * @param templates List of templates in a Solution
+   * @param sortOrderIds List of template ids in the desired sort order
+   */
+  function sortTemplates(templates, sortOrderIds) {
+      templates.sort((template1, template2) => sortOrderIds.indexOf(template1.itemId) -
+          sortOrderIds.indexOf(template2.itemId));
+  }
 
-    /**
-     * Sorts a list of templates in place to match a provided sort-order list.
-     *
-     * @param templates List of templates in a Solution
-     * @param sortOrderIds List of template ids in the desired sort order
-     */
-    function sortTemplates(templates, sortOrderIds) {
-        templates.sort(function (template1, template2) {
-            return sortOrderIds.indexOf(template1.itemId) -
-                sortOrderIds.indexOf(template2.itemId);
-        });
-    }
+  /** @license
+   * Copyright 2018 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  // NOTE: Moved to separate file to allow stubbing in main deploySolution tests
+  function deploySolutionFromTemplate(templateSolutionId, solutionTemplateBase, solutionTemplateData, authentication, options) {
+      options.storageVersion = common.extractSolutionVersion(solutionTemplateData);
+      return new Promise((resolve, reject) => {
+          // It is possible to provide a separate authentication for the source
+          const storageAuthentication = options.storageAuthentication
+              ? options.storageAuthentication
+              : authentication;
+          // Replacement dictionary and high-level deployment ids for cleanup
+          // TODO: Extract all templateDictionary prep into a separate function
+          const templateDictionary = options.templateDictionary ?? {};
+          let deployedFolderId;
+          let deployedSolutionId;
+          _applySourceToDeployOptions(options, solutionTemplateBase, templateDictionary, authentication);
+          if (options.additionalTypeKeywords) {
+              solutionTemplateBase.typeKeywords = [].concat(solutionTemplateBase.typeKeywords, options.additionalTypeKeywords);
+          }
+          // Get the thumbnail file
+          let thumbFilename = "thumbnail";
+          let thumbDef = Promise.resolve(null);
+          if (!options.thumbnail && options.thumbnailurl) {
+              // Figure out the thumbnail's filename
+              thumbFilename =
+                  common.getFilenameFromUrl(options.thumbnailurl) || thumbFilename;
+              const thumbnailurl = common.appendQueryParam(options.thumbnailurl, "w=400");
+              delete options.thumbnailurl;
+              // Fetch the thumbnail
+              thumbDef = common.getBlobAsFile(thumbnailurl, thumbFilename, storageAuthentication, [400]);
+          }
+          _replaceParamVariables(solutionTemplateData, templateDictionary);
+          // Get information about deployment environment
+          Promise.all([
+              common.getPortal("", authentication),
+              common.getUser(authentication),
+              common.getFoldersAndGroups(authentication),
+              thumbDef
+          ])
+              .then(responses => {
+              const [portalResponse, userResponse, foldersAndGroupsResponse, thumbnailFile] = responses;
+              if (!options.thumbnail && thumbnailFile) {
+                  options.thumbnail = thumbnailFile;
+              }
+              // update template items with source-itemId type keyword
+              solutionTemplateData.templates = solutionTemplateData.templates.map((template) => {
+                  const sourceId = "source-" + template.itemId;
+                  /* istanbul ignore else */
+                  if (template.item) {
+                      /* istanbul ignore else */
+                      if (template.item.typeKeywords) {
+                          template.item.typeKeywords.push(sourceId);
+                      }
+                      /* istanbul ignore else */
+                      if (template.item.tags &&
+                          common.getProp(template, "item.type") === "Group") {
+                          template.item.tags.push(sourceId);
+                      }
+                  }
+                  return template;
+              });
+              templateDictionary.isPortal = portalResponse.isPortal;
+              templateDictionary.organization = Object.assign(templateDictionary.organization || {}, portalResponse);
+              // TODO: Add more computed properties here
+              // portal: portalResponse
+              // orgextent as bbox for assignment onto items
+              // more info in #266 https://github.com/Esri/solution.js/issues/266
+              templateDictionary.portalBaseUrl = _getPortalBaseUrl(portalResponse, authentication);
+              templateDictionary.user = userResponse;
+              templateDictionary.user.folders = foldersAndGroupsResponse.folders;
+              templateDictionary.user.groups = foldersAndGroupsResponse.groups.filter((group) => group.owner === templateDictionary.user.username);
+              // if we have tracking views and the user is not admin or the org doesn't support tracking an error is thrown
+              common.setLocationTrackingEnabled(portalResponse, userResponse, templateDictionary, solutionTemplateData.templates);
+              const trackingOwnerPromise = common.getTackingServiceOwner(templateDictionary, authentication);
+              // Create a folder to hold the deployed solution. We use the solution name, appending a sequential
+              // suffix if the folder exists, e.g.,
+              //  * Manage Right of Way Activities
+              //  * Manage Right of Way Activities 1
+              //  * Manage Right of Way Activities 2
+              const folderPromise = common.createUniqueFolder(solutionTemplateBase.title, templateDictionary, authentication);
+              // Apply the portal extents to the solution
+              const portalExtent = portalResponse.defaultExtent;
+              const extentsPromise = common.convertExtentWithFallback(portalExtent, undefined, { wkid: 4326 }, portalResponse.helperServices.geometry.url, authentication);
+              // Await completion of async actions: folder creation & extents conversion
+              return Promise.all([folderPromise, extentsPromise, trackingOwnerPromise]);
+          })
+              .then(responses => {
+              const [folderResponse, wgs84Extent, trackingOwnerResponse] = responses;
+              deployedFolderId = folderResponse.folder.id;
+              templateDictionary.folderId = deployedFolderId;
+              templateDictionary.solutionItemExtent =
+                  wgs84Extent.xmin +
+                      "," +
+                      wgs84Extent.ymin +
+                      "," +
+                      wgs84Extent.xmax +
+                      "," +
+                      wgs84Extent.ymax;
+              // Hub Solutions depend on organization defaultExtentBBox as a nested array not a string
+              templateDictionary.organization.defaultExtentBBox = [
+                  [wgs84Extent.xmin, wgs84Extent.ymin],
+                  [wgs84Extent.xmax, wgs84Extent.ymax]
+              ];
+              // update templateDictionary to indicate if the user owns the tracking service
+              // this will affect how we handle group sharing
+              /* istanbul ignore else */
+              if (templateDictionary.locationTrackingEnabled) {
+                  common.setCreateProp(templateDictionary, "locationTracking.userIsOwner", trackingOwnerResponse);
+              }
+              // Create a deployed Solution item
+              const createSolutionItemBase = {
+                  ...common.sanitizeJSONAndReportChanges(solutionTemplateBase),
+                  type: "Solution",
+                  typeKeywords: ["Solution"]
+              };
+              if (options.additionalTypeKeywords) {
+                  createSolutionItemBase.typeKeywords = ["Solution"].concat(options.additionalTypeKeywords);
+              }
+              // Create deployed solution item
+              createSolutionItemBase.thumbnail = options.thumbnail;
+              return common.createItemWithData(createSolutionItemBase, {}, authentication, deployedFolderId);
+          })
+              .then(createSolutionResponse => {
+              deployedSolutionId = createSolutionResponse.id;
+              // Protect the solution item
+              const protectOptions = {
+                  id: deployedSolutionId,
+                  authentication
+              };
+              return portal.protectItem(protectOptions);
+          })
+              .then(() => {
+              // TODO: Attach the whole solution model so we can
+              // have stuff like `{{solution.item.title}}
+              templateDictionary.solutionItemId = deployedSolutionId;
+              solutionTemplateBase.id = deployedSolutionId;
+              solutionTemplateBase.tryitUrl = _checkedReplaceAll(solutionTemplateBase.tryitUrl, templateSolutionId, deployedSolutionId);
+              solutionTemplateBase.url = _checkedReplaceAll(solutionTemplateBase.url, templateSolutionId, deployedSolutionId);
+              // Handle the contained item templates
+              return deploySolutionItems(storageAuthentication.portal, templateSolutionId, solutionTemplateData.templates, storageAuthentication, templateDictionary, deployedSolutionId, authentication, options);
+          })
+              .then((clonedSolutionsResponse) => {
+              solutionTemplateData.templates = solutionTemplateData.templates.map((itemTemplate) => {
+                  // Update ids present in template dictionary
+                  itemTemplate.itemId = common.getProp(templateDictionary, `${itemTemplate.itemId}.itemId`);
+                  // Update the dependencies hash to point to the new item ids
+                  itemTemplate.dependencies = itemTemplate.dependencies.map((id) => hubCommon.getWithDefault(templateDictionary, `${id}.itemId`, id));
+                  return itemTemplate;
+              });
+              // Sort the templates into build order, which is provided by clonedSolutionsResponse
+              sortTemplates(solutionTemplateData.templates, clonedSolutionsResponse.map(response => response.id));
+              // Wrap up with post-processing, in which we deal with groups and cycle remnants
+              return postProcess(deployedSolutionId, solutionTemplateData.templates, clonedSolutionsResponse, authentication, templateDictionary);
+          })
+              .then(() => {
+              // Update solution item using internal representation & and the updated data JSON
+              solutionTemplateBase.typeKeywords = [].concat(solutionTemplateBase.typeKeywords, ["Deployed"]);
+              const iTemplateKeyword = solutionTemplateBase.typeKeywords.indexOf("Template");
+              /* istanbul ignore else */
+              if (iTemplateKeyword >= 0) {
+                  solutionTemplateBase.typeKeywords.splice(iTemplateKeyword, 1);
+              }
+              solutionTemplateData.templates = solutionTemplateData.templates.map((itemTemplate) => _purgeTemplateProperties(itemTemplate));
+              solutionTemplateData.templates = _updateGroupReferences(solutionTemplateData.templates, templateDictionary);
+              // Update solution items data using template dictionary, and then update the
+              // itemId & dependencies in each item template
+              solutionTemplateBase.data = common.replaceInTemplate(solutionTemplateData, templateDictionary);
+              // Write any user defined params to the solution
+              /* istanbul ignore else */
+              if (templateDictionary.params) {
+                  solutionTemplateBase.data.params = templateDictionary.params;
+              }
+              return common.updateItem(solutionTemplateBase, authentication, deployedFolderId);
+          })
+              .then(() => resolve(solutionTemplateBase.id), reject);
+      });
+  }
+  /**
+   * Update the deployOptions with the group properties
+   *
+   * @param deployOptions
+   * @param sourceInfo
+   * @param authentication
+   * @param isGroup Boolean to indicate if the files are associated with a group or item
+   * @internal
+   */
+  function _applySourceToDeployOptions(deployOptions, solutionTemplateBase, templateDictionary, authentication) {
+      // Deploy a solution from the template's contents,
+      // using the template's information as defaults for the deployed solution item
+      ["title", "snippet", "description", "tags"].forEach(prop => {
+          deployOptions[prop] = deployOptions[prop] ?? solutionTemplateBase[prop];
+          if (deployOptions[prop]) {
+              solutionTemplateBase[prop] = deployOptions[prop];
+              // carry these options forward on the templateDict
+              templateDictionary[prop] = deployOptions[prop];
+          }
+      });
+      if (!deployOptions.thumbnailurl && solutionTemplateBase.thumbnail) {
+          // Get the full path to the thumbnail
+          deployOptions.thumbnailurl = common.generateSourceThumbnailUrl(authentication.portal, solutionTemplateBase.id, solutionTemplateBase.thumbnail);
+          delete solutionTemplateBase.thumbnail;
+      }
+      return deployOptions;
+  }
+  function _replaceParamVariables(solutionTemplateData, templateDictionary) {
+      // a custom params object can be passed in with the options to deploy a solution
+      // in most cases we can defer to the item type handlers to use these values
+      // for variable replacement
+      // for spatial reference specifically we need to replace up front so the default extent
+      // logic can execute as expected
+      solutionTemplateData.templates = solutionTemplateData.templates.map((template) => {
+          // can't do this as it causes other values that don't exist in the dict yet to revert to defaults they may have defined
+          // return common.replaceInTemplate(template, templateDictionary);
+          /* istanbul ignore else */
+          if (template.type === "Feature Service") {
+              const paramsLookup = "params.";
+              const wkidItemPath = "item.spatialReference.wkid";
+              template = _updateProp(template, wkidItemPath, paramsLookup, templateDictionary);
+              const wkidServicePath = "properties.service.spatialReference.wkid";
+              template = _updateProp(template, wkidServicePath, paramsLookup, templateDictionary);
+          }
+          return template;
+      });
+  }
+  function _updateProp(template, path, lookup, templateDictionary) {
+      const wkid = common.getProp(template, path);
+      /* istanbul ignore else */
+      if (wkid && typeof wkid === "string" && wkid.indexOf(lookup) > -1) {
+          common.setProp(template, path, common.replaceInTemplate(wkid, templateDictionary));
+      }
+      return template;
+  }
+  function _checkedReplaceAll(template, oldValue, newValue) {
+      let newTemplate;
+      if (template && template.indexOf(oldValue) > -1) {
+          const re = new RegExp(oldValue, "g");
+          newTemplate = template.replace(re, newValue);
+      }
+      else {
+          newTemplate = template;
+      }
+      return newTemplate;
+  }
+  function _getPortalBaseUrl(portalResponse, authentication) {
+      // As of Spring 2020, only HTTPS (see
+      // https://www.esri.com/arcgis-blog/products/product/administration/2019-arcgis-transport-security-improvements/)
+      const scheme = "https"; // portalResponse.allSSL ? "https" : "http";
+      const urlKey = common.getProp(portalResponse, "urlKey");
+      const customBaseUrl = common.getProp(portalResponse, "customBaseUrl");
+      const enterpriseBaseUrl = common.getProp(portalResponse, "portalHostname");
+      return urlKey && customBaseUrl
+          ? `${scheme}://${urlKey}.${customBaseUrl}`
+          : enterpriseBaseUrl
+              ? `${scheme}://${enterpriseBaseUrl}`
+              : authentication.portal.replace("/sharing/rest", "");
+  }
+  function _updateGroupReferences(itemTemplates, templateDictionary) {
+      const groupIds = itemTemplates.reduce((result, t) => {
+          if (t.type === "Group") {
+              result.push(t.itemId);
+          }
+          return result;
+      }, []);
+      Object.keys(templateDictionary).forEach(k => {
+          const newId = templateDictionary[k].itemId;
+          if (groupIds.indexOf(newId) > -1) {
+              itemTemplates.forEach(t => {
+                  t.groups = t.groups.map((id) => (id === k ? newId : id));
+              });
+          }
+      });
+      return itemTemplates;
+  }
+  function _purgeTemplateProperties(itemTemplate) {
+      const retainProps = ["itemId", "type", "dependencies", "groups"];
+      const deleteProps = Object.keys(itemTemplate).filter(k => retainProps.indexOf(k) < 0);
+      common.deleteProps(itemTemplate, deleteProps);
+      return itemTemplate;
+  }
 
-    /** @license
-     * Copyright 2018 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    // NOTE: Moved to separate file to allow stubbing in main deploySolution tests
-    function deploySolutionFromTemplate(templateSolutionId, solutionTemplateBase, solutionTemplateData, authentication, options) {
-        options.storageVersion = common.extractSolutionVersion(solutionTemplateData);
-        return new Promise(function (resolve, reject) {
-            var _a;
-            // It is possible to provide a separate authentication for the source
-            var storageAuthentication = options.storageAuthentication
-                ? options.storageAuthentication
-                : authentication;
-            // Replacement dictionary and high-level deployment ids for cleanup
-            // TODO: Extract all templateDictionary prep into a separate function
-            var templateDictionary = (_a = options.templateDictionary) !== null && _a !== void 0 ? _a : {};
-            var deployedFolderId;
-            var deployedSolutionId;
-            _applySourceToDeployOptions(options, solutionTemplateBase, templateDictionary, authentication);
-            if (options.additionalTypeKeywords) {
-                solutionTemplateBase.typeKeywords = [].concat(solutionTemplateBase.typeKeywords, options.additionalTypeKeywords);
-            }
-            // Get the thumbnail file
-            var thumbFilename = "thumbnail";
-            var thumbDef = Promise.resolve(null);
-            if (!options.thumbnail && options.thumbnailurl) {
-                // Figure out the thumbnail's filename
-                thumbFilename =
-                    common.getFilenameFromUrl(options.thumbnailurl) || thumbFilename;
-                var thumbnailurl = common.appendQueryParam(options.thumbnailurl, "w=400");
-                delete options.thumbnailurl;
-                // Fetch the thumbnail
-                thumbDef = common.getBlobAsFile(thumbnailurl, thumbFilename, storageAuthentication, [400]);
-            }
-            _replaceParamVariables(solutionTemplateData, templateDictionary);
-            // Get information about deployment environment
-            Promise.all([
-                common.getPortal("", authentication),
-                common.getUser(authentication),
-                common.getFoldersAndGroups(authentication),
-                thumbDef
-            ])
-                .then(function (responses) {
-                var _a = __read(responses, 4), portalResponse = _a[0], userResponse = _a[1], foldersAndGroupsResponse = _a[2], thumbnailFile = _a[3];
-                if (!options.thumbnail && thumbnailFile) {
-                    options.thumbnail = thumbnailFile;
-                }
-                // update template items with source-itemId type keyword
-                solutionTemplateData.templates = solutionTemplateData.templates.map(function (template) {
-                    var sourceId = "source-" + template.itemId;
-                    /* istanbul ignore else */
-                    if (template.item) {
-                        /* istanbul ignore else */
-                        if (template.item.typeKeywords) {
-                            template.item.typeKeywords.push(sourceId);
-                        }
-                        /* istanbul ignore else */
-                        if (template.item.tags &&
-                            common.getProp(template, "item.type") === "Group") {
-                            template.item.tags.push(sourceId);
-                        }
-                    }
-                    return template;
-                });
-                templateDictionary.isPortal = portalResponse.isPortal;
-                templateDictionary.organization = Object.assign(templateDictionary.organization || {}, portalResponse);
-                // TODO: Add more computed properties here
-                // portal: portalResponse
-                // orgextent as bbox for assignment onto items
-                // more info in #266 https://github.com/Esri/solution.js/issues/266
-                templateDictionary.portalBaseUrl = _getPortalBaseUrl(portalResponse, authentication);
-                templateDictionary.user = userResponse;
-                templateDictionary.user.folders = foldersAndGroupsResponse.folders;
-                templateDictionary.user.groups = foldersAndGroupsResponse.groups.filter(function (group) {
-                    return group.owner === templateDictionary.user.username;
-                });
-                // Create a folder to hold the deployed solution. We use the solution name, appending a sequential
-                // suffix if the folder exists, e.g.,
-                //  * Manage Right of Way Activities
-                //  * Manage Right of Way Activities 1
-                //  * Manage Right of Way Activities 2
-                var folderPromise = common.createUniqueFolder(solutionTemplateBase.title, templateDictionary, authentication);
-                // Apply the portal extents to the solution
-                var portalExtent = portalResponse.defaultExtent;
-                var extentsPromise = common.convertExtentWithFallback(portalExtent, undefined, { wkid: 4326 }, portalResponse.helperServices.geometry.url, authentication);
-                // Await completion of async actions: folder creation & extents conversion
-                return Promise.all([folderPromise, extentsPromise]);
-            })
-                .then(function (responses) {
-                var _a = __read(responses, 2), folderResponse = _a[0], wgs84Extent = _a[1];
-                deployedFolderId = folderResponse.folder.id;
-                templateDictionary.folderId = deployedFolderId;
-                templateDictionary.solutionItemExtent =
-                    wgs84Extent.xmin +
-                        "," +
-                        wgs84Extent.ymin +
-                        "," +
-                        wgs84Extent.xmax +
-                        "," +
-                        wgs84Extent.ymax;
-                // Hub Solutions depend on organization defaultExtentBBox as a nested array not a string
-                templateDictionary.organization.defaultExtentBBox = [
-                    [wgs84Extent.xmin, wgs84Extent.ymin],
-                    [wgs84Extent.xmax, wgs84Extent.ymax]
-                ];
-                // Create a deployed Solution item
-                var createSolutionItemBase = __assign(__assign({}, common.sanitizeJSONAndReportChanges(solutionTemplateBase)), { type: "Solution", typeKeywords: ["Solution"] });
-                if (options.additionalTypeKeywords) {
-                    createSolutionItemBase.typeKeywords = ["Solution"].concat(options.additionalTypeKeywords);
-                }
-                // Create deployed solution item
-                createSolutionItemBase.thumbnail = options.thumbnail;
-                return common.createItemWithData(createSolutionItemBase, {}, authentication, deployedFolderId);
-            })
-                .then(function (createSolutionResponse) {
-                deployedSolutionId = createSolutionResponse.id;
-                // TODO: Attach the whole solution model so we can
-                // have stuff like `{{solution.item.title}}
-                templateDictionary.solutionItemId = deployedSolutionId;
-                solutionTemplateBase.id = deployedSolutionId;
-                solutionTemplateBase.tryitUrl = _checkedReplaceAll(solutionTemplateBase.tryitUrl, templateSolutionId, deployedSolutionId);
-                solutionTemplateBase.url = _checkedReplaceAll(solutionTemplateBase.url, templateSolutionId, deployedSolutionId);
-                // Handle the contained item templates
-                return deploySolutionItems(storageAuthentication.portal, templateSolutionId, solutionTemplateData.templates, storageAuthentication, templateDictionary, authentication, options);
-            })
-                .then(function (clonedSolutionsResponse) {
-                solutionTemplateData.templates = solutionTemplateData.templates.map(function (itemTemplate) {
-                    // Update ids present in template dictionary
-                    itemTemplate.itemId = common.getProp(templateDictionary, itemTemplate.itemId + ".itemId");
-                    // Update the dependencies hash to point to the new item ids
-                    itemTemplate.dependencies = itemTemplate.dependencies.map(function (id) {
-                        return hubCommon.getWithDefault(templateDictionary, id + ".itemId", id);
-                    });
-                    return itemTemplate;
-                });
-                // Sort the templates into build order, which is provided by clonedSolutionsResponse
-                sortTemplates(solutionTemplateData.templates, clonedSolutionsResponse.map(function (response) { return response.id; }));
-                // Wrap up with post-processing, in which we deal with groups and cycle remnants
-                return postProcess(deployedSolutionId, solutionTemplateData.templates, clonedSolutionsResponse, authentication, templateDictionary);
-            })
-                .then(function () {
-                // Update solution item using internal representation & and the updated data JSON
-                solutionTemplateBase.typeKeywords = [].concat(solutionTemplateBase.typeKeywords, ["Deployed"]);
-                var iTemplateKeyword = solutionTemplateBase.typeKeywords.indexOf("Template");
-                /* istanbul ignore else */
-                if (iTemplateKeyword >= 0) {
-                    solutionTemplateBase.typeKeywords.splice(iTemplateKeyword, 1);
-                }
-                solutionTemplateData.templates = solutionTemplateData.templates.map(function (itemTemplate) {
-                    return _purgeTemplateProperties(itemTemplate);
-                });
-                solutionTemplateData.templates = _updateGroupReferences(solutionTemplateData.templates, templateDictionary);
-                // Update solution items data using template dictionary, and then update the
-                // itemId & dependencies in each item template
-                solutionTemplateBase.data = common.replaceInTemplate(solutionTemplateData, templateDictionary);
-                // Write any user defined params to the solution
-                /* istanbul ignore else */
-                if (templateDictionary.params) {
-                    solutionTemplateBase.data.params = templateDictionary.params;
-                }
-                return common.updateItem(solutionTemplateBase, authentication, deployedFolderId);
-            })
-                .then(function () { return resolve(solutionTemplateBase.id); }, function (error) {
-                // Cleanup solution folder and deployed solution item
-                var cleanupPromises = [];
-                if (deployedFolderId) {
-                    cleanupPromises.push(common.removeFolder(deployedFolderId, authentication));
-                }
-                if (deployedSolutionId) {
-                    cleanupPromises.push(common.removeItem(deployedSolutionId, authentication));
-                }
-                Promise.all(cleanupPromises).then(function () { return reject(error); }, function () { return reject(error); });
-            });
-        });
-    }
-    /**
-     * Update the deployOptions with the group properties
-     *
-     * @param deployOptions
-     * @param sourceInfo
-     * @param authentication
-     * @param isGroup Boolean to indicate if the files are associated with a group or item
-     * @internal
-     */
-    function _applySourceToDeployOptions(deployOptions, solutionTemplateBase, templateDictionary, authentication) {
-        // Deploy a solution from the template's contents,
-        // using the template's information as defaults for the deployed solution item
-        ["title", "snippet", "description", "tags"].forEach(function (prop) {
-            var _a;
-            deployOptions[prop] = (_a = deployOptions[prop]) !== null && _a !== void 0 ? _a : solutionTemplateBase[prop];
-            if (deployOptions[prop]) {
-                solutionTemplateBase[prop] = deployOptions[prop];
-                // carry these options forward on the templateDict
-                templateDictionary[prop] = deployOptions[prop];
-            }
-        });
-        if (!deployOptions.thumbnailurl && solutionTemplateBase.thumbnail) {
-            // Get the full path to the thumbnail
-            deployOptions.thumbnailurl = common.generateSourceThumbnailUrl(authentication.portal, solutionTemplateBase.id, solutionTemplateBase.thumbnail);
-            delete solutionTemplateBase.thumbnail;
-        }
-        return deployOptions;
-    }
-    function _replaceParamVariables(solutionTemplateData, templateDictionary) {
-        // a custom params object can be passed in with the options to deploy a solution
-        // in most cases we can defer to the item type handlers to use these values
-        // for variable replacement
-        // for spatial reference specifically we need to replace up front so the default extent
-        // logic can execute as expected
-        solutionTemplateData.templates = solutionTemplateData.templates.map(function (template) {
-            // can't do this as it causes other values that don't exist in the dict yet to revert to defaults they may have defined
-            // return common.replaceInTemplate(template, templateDictionary);
-            /* istanbul ignore else */
-            if (template.type === "Feature Service") {
-                var paramsLookup = "params.";
-                var wkidItemPath = "item.spatialReference.wkid";
-                template = _updateProp(template, wkidItemPath, paramsLookup, templateDictionary);
-                var wkidServicePath = "properties.service.spatialReference.wkid";
-                template = _updateProp(template, wkidServicePath, paramsLookup, templateDictionary);
-            }
-            return template;
-        });
-    }
-    function _updateProp(template, path, lookup, templateDictionary) {
-        var wkid = common.getProp(template, path);
-        /* istanbul ignore else */
-        if (wkid && typeof wkid === "string" && wkid.indexOf(lookup) > -1) {
-            common.setProp(template, path, common.replaceInTemplate(wkid, templateDictionary));
-        }
-        return template;
-    }
-    function _checkedReplaceAll(template, oldValue, newValue) {
-        var newTemplate;
-        if (template && template.indexOf(oldValue) > -1) {
-            var re = new RegExp(oldValue, "g");
-            newTemplate = template.replace(re, newValue);
-        }
-        else {
-            newTemplate = template;
-        }
-        return newTemplate;
-    }
-    function _getPortalBaseUrl(portalResponse, authentication) {
-        // As of Spring 2020, only HTTPS (see
-        // https://www.esri.com/arcgis-blog/products/product/administration/2019-arcgis-transport-security-improvements/)
-        var scheme = "https"; // portalResponse.allSSL ? "https" : "http";
-        var urlKey = common.getProp(portalResponse, "urlKey");
-        var customBaseUrl = common.getProp(portalResponse, "customBaseUrl");
-        var enterpriseBaseUrl = common.getProp(portalResponse, "portalHostname");
-        return urlKey && customBaseUrl
-            ? scheme + "://" + urlKey + "." + customBaseUrl
-            : enterpriseBaseUrl
-                ? scheme + "://" + enterpriseBaseUrl
-                : authentication.portal.replace("/sharing/rest", "");
-    }
-    function _updateGroupReferences(itemTemplates, templateDictionary) {
-        var groupIds = itemTemplates.reduce(function (result, t) {
-            if (t.type === "Group") {
-                result.push(t.itemId);
-            }
-            return result;
-        }, []);
-        Object.keys(templateDictionary).forEach(function (k) {
-            var newId = templateDictionary[k].itemId;
-            if (groupIds.indexOf(newId) > -1) {
-                itemTemplates.forEach(function (t) {
-                    t.groups = t.groups.map(function (id) { return (id === k ? newId : id); });
-                });
-            }
-        });
-        return itemTemplates;
-    }
-    function _purgeTemplateProperties(itemTemplate) {
-        var retainProps = ["itemId", "type", "dependencies", "groups"];
-        var deleteProps = Object.keys(itemTemplate).filter(function (k) { return retainProps.indexOf(k) < 0; });
-        common.deleteProps(itemTemplate, deleteProps);
-        return itemTemplate;
-    }
+  /** @license
+   * Copyright 2018 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  /**
+   * Given an itemId or an object, either fetch the item or
+   * resolve using the object, if it is structured as expected
+   *
+   * @param idOrObject string || object like `{item:{...}, data: {...}}`
+   * @param authentication UserSession
+   */
+  function getSolutionTemplateItem(idOrObject, authentication) {
+      if (typeof idOrObject === "string") {
+          // get the item + data
+          return Promise.all([
+              common.getItemBase(idOrObject, authentication),
+              common.getItemDataAsJson(idOrObject, authentication)
+          ]).then(([item, data]) => {
+              // format into a model and migrate the schema
+              return common.migrateSchema({
+                  item,
+                  data
+              });
+          });
+      }
+      else {
+          // check if it is a "Model"
+          if (_isModel(idOrObject)) {
+              // run migrations
+              return common.migrateSchema(idOrObject);
+          }
+          else {
+              return Promise.reject(common.fail(`getSolutionTemplateItem must be passed an item id or a model object`));
+          }
+      }
+  }
+  /**
+   * Update the Deploy Options with information from the
+   * Solution Template item
+   *
+   * @param deployOptions
+   * @param item
+   * @param authentication
+   */
+  function updateDeployOptions(deployOptions, item, authentication) {
+      deployOptions.jobId = deployOptions.jobId ?? item.id;
+      deployOptions.title = deployOptions.title ?? item.title;
+      deployOptions.snippet = deployOptions.snippet ?? item.snippet;
+      deployOptions.description = deployOptions.description ?? item.description;
+      deployOptions.tags = deployOptions.tags ?? item.tags;
+      // add the thumbnail url
+      deployOptions.thumbnailurl = item.thumbnail
+          ? common.getItemThumbnailUrl(item.id, item.thumbnail, false, authentication)
+          : null;
+      return deployOptions;
+  }
+  /**
+   * Check if an object is an Model
+   *
+   * @param obj any object
+   */
+  function _isModel(obj) {
+      let result = false;
+      // TODO Hoist into common?
+      const isNotStringOrArray = (v) => v != null &&
+          typeof v !== "string" &&
+          !Array.isArray(v) &&
+          typeof v === "object";
+      if (isNotStringOrArray(obj)) {
+          result = ["item", "data"].reduce((acc, prop) => {
+              if (acc) {
+                  acc = isNotStringOrArray(obj[prop]);
+              }
+              return acc;
+          }, true);
+      }
+      return result;
+  }
+  /**
+   * Does the item have the correct type and keywords
+   * to be a Solution Template item?
+   *
+   * @param item IItem
+   */
+  function isSolutionTemplateItem(item) {
+      const kwds = item.typeKeywords;
+      // Solution items
+      let result = false;
+      if (item.type === "Solution") {
+          if (kwds.indexOf("Solution") > -1 &&
+              (kwds.indexOf("Template") > -1 || kwds.indexOf("solutionTemplate") > -1)) {
+              result = true;
+          }
+      }
+      // Older Hub Solutions used Web Mapping Application items
+      if (item.type === "Web Mapping Application") {
+          if (kwds.indexOf("hubSolutionTemplate") > -1) {
+              result = true;
+          }
+      }
+      return result;
+  }
 
-    /** @license
-     * Copyright 2018 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    /**
-     * Given an itemId or an object, either fetch the item or
-     * resolve using the object, if it is structured as expected
-     *
-     * @param idOrObject string || object like `{item:{...}, data: {...}}`
-     * @param authentication UserSession
-     */
-    function getSolutionTemplateItem(idOrObject, authentication) {
-        if (typeof idOrObject === "string") {
-            // get the item + data
-            return Promise.all([
-                common.getItemBase(idOrObject, authentication),
-                common.getItemDataAsJson(idOrObject, authentication)
-            ]).then(function (_a) {
-                var _b = __read(_a, 2), item = _b[0], data = _b[1];
-                // format into a model and migrate the schema
-                return common.migrateSchema({
-                    item: item,
-                    data: data
-                });
-            });
-        }
-        else {
-            // check if it is a "Model"
-            if (_isModel(idOrObject)) {
-                // run migrations
-                return common.migrateSchema(idOrObject);
-            }
-            else {
-                return Promise.reject(common.fail("getSolutionTemplateItem must be passed an item id or a model object"));
-            }
-        }
-    }
-    /**
-     * Update the Deploy Options with information from the
-     * Solution Template item
-     *
-     * @param deployOptions
-     * @param item
-     * @param authentication
-     */
-    function updateDeployOptions(deployOptions, item, authentication) {
-        var _a, _b, _c, _d, _e;
-        deployOptions.jobId = (_a = deployOptions.jobId) !== null && _a !== void 0 ? _a : item.id;
-        deployOptions.title = (_b = deployOptions.title) !== null && _b !== void 0 ? _b : item.title;
-        deployOptions.snippet = (_c = deployOptions.snippet) !== null && _c !== void 0 ? _c : item.snippet;
-        deployOptions.description = (_d = deployOptions.description) !== null && _d !== void 0 ? _d : item.description;
-        deployOptions.tags = (_e = deployOptions.tags) !== null && _e !== void 0 ? _e : item.tags;
-        // add the thumbnail url
-        deployOptions.thumbnailurl = item.thumbnail
-            ? common.getItemThumbnailUrl(item.id, item.thumbnail, false, authentication)
-            : null;
-        return deployOptions;
-    }
-    /**
-     * Check if an object is an Model
-     *
-     * @param obj any object
-     */
-    function _isModel(obj) {
-        var result = false;
-        // TODO Hoist into common?
-        var isNotStringOrArray = function (v) {
-            return v != null &&
-                typeof v !== "string" &&
-                !Array.isArray(v) &&
-                typeof v === "object";
-        };
-        if (isNotStringOrArray(obj)) {
-            result = ["item", "data"].reduce(function (acc, prop) {
-                if (acc) {
-                    acc = isNotStringOrArray(obj[prop]);
-                }
-                return acc;
-            }, true);
-        }
-        return result;
-    }
-    /**
-     * Does the item have the correct type and keywords
-     * to be a Solution Template item?
-     *
-     * @param item IItem
-     */
-    function isSolutionTemplateItem(item) {
-        var kwds = item.typeKeywords;
-        // Solution items
-        var result = false;
-        if (item.type === "Solution") {
-            if (kwds.indexOf("Solution") > -1 &&
-                (kwds.indexOf("Template") > -1 || kwds.indexOf("solutionTemplate") > -1)) {
-                result = true;
-            }
-        }
-        // Older Hub Solutions used Web Mapping Application items
-        if (item.type === "Web Mapping Application") {
-            if (kwds.indexOf("hubSolutionTemplate") > -1) {
-                result = true;
-            }
-        }
-        return result;
-    }
+  /** @license
+   * Copyright 2018 Esri
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *    http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+  /**
+   * Deploy a Solution
+   *
+   * Pass in either the item id or an IModel (`{item:{}, model:{}}`)
+   * of a Solution Template, and this will generate the Solution
+   *
+   * @param maybeModel Item Id or IModel
+   * @param authentication Credentials for the destination organization
+   * @param options Options to override deployed information and to provide additional credentials
+   * @return The id of the created deployed solution item
+   */
+  function deploySolution(maybeModel, authentication, options) {
+      // if we are not passed the maybeModel, reject
+      if (!maybeModel) {
+          return Promise.reject(common.fail("The Solution Template id is missing"));
+      }
+      let deployOptions = options || {};
+      /* istanbul ignore else */
+      if (deployOptions.progressCallback) {
+          deployOptions.progressCallback(1, deployOptions.jobId); // let the caller know that we've started
+      }
+      // It is possible to provide a separate authentication for the source
+      const storageAuthentication = deployOptions.storageAuthentication
+          ? deployOptions.storageAuthentication
+          : authentication;
+      // deal with maybe getting an item or an id
+      return getSolutionTemplateItem(maybeModel, storageAuthentication)
+          .then(model => {
+          if (!isSolutionTemplateItem(model.item)) {
+              return Promise.reject(common.fail(`${model.item.id} is not a Solution Template`));
+          }
+          else {
+              // fetch the metadata if the model's id is a GUID and pass the item & data forward
+              return Promise.all([
+                  Promise.resolve(model.item),
+                  Promise.resolve(model.data)
+              ]);
+          }
+      })
+          .then(responses => {
+          // extract responses
+          const [itemBase, itemData] = responses;
+          // sanitize all the things
+          const sanitizer = new common.Sanitizer();
+          const item = common.sanitizeJSONAndReportChanges(itemBase, sanitizer);
+          // TODO: we should delegate data sanization to the type-specific modules
+          const data = itemData;
+          // get the item id before it is deleted
+          const itemId = item.id;
+          // apply item props to deployOptions
+          deployOptions = updateDeployOptions(deployOptions, item, storageAuthentication);
+          // Clone before mutating? This was messing me up in some testing...
+          common.deleteItemProps(item);
+          return deploySolutionFromTemplate(itemId, item, data, authentication, deployOptions);
+      })
+          .then(createdSolutionId => {
+          /* istanbul ignore else */
+          if (deployOptions.progressCallback) {
+              deployOptions.progressCallback(100, deployOptions.jobId); // we're done
+          }
+          return createdSolutionId;
+      }, error => {
+          // Error deploying solution
+          /* istanbul ignore else */
+          if (deployOptions.progressCallback) {
+              deployOptions.progressCallback(1, deployOptions.jobId);
+          }
+          return Promise.reject(error);
+      })
+          .catch(ex => {
+          throw ex;
+      });
+  }
 
-    /** @license
-     * Copyright 2018 Esri
-     *
-     * Licensed under the Apache License, Version 2.0 (the "License");
-     * you may not use this file except in compliance with the License.
-     * You may obtain a copy of the License at
-     *
-     *    http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-    /**
-     * Deploy a Solution
-     *
-     * Pass in either the item id or an IModel (`{item:{}, model:{}}`)
-     * of a Solution Template, and this will generate the Solution
-     *
-     * @param maybeModel Item Id or IModel
-     * @param authentication Credentials for the destination organization
-     * @param options Options to override deployed information and to provide additional credentials
-     * @return The id of the created deployed solution item
-     */
-    function deploySolution(maybeModel, authentication, options) {
-        // if we are not passed the maybeModel, reject
-        if (!maybeModel) {
-            return Promise.reject(common.fail("The Solution Template id is missing"));
-        }
-        var deployOptions = options || {};
-        /* istanbul ignore else */
-        if (deployOptions.progressCallback) {
-            deployOptions.progressCallback(1); // let the caller know that we've started
-        }
-        // It is possible to provide a separate authentication for the source
-        var storageAuthentication = deployOptions.storageAuthentication
-            ? deployOptions.storageAuthentication
-            : authentication;
-        // deal with maybe getting an item or an id
-        return getSolutionTemplateItem(maybeModel, storageAuthentication)
-            .then(function (model) {
-            if (!isSolutionTemplateItem(model.item)) {
-                return Promise.reject(common.fail(model.item.id + " is not a Solution Template"));
-            }
-            else {
-                // fetch the metadata if the model's id is a GUID and pass the item & data forward
-                return Promise.all([
-                    Promise.resolve(model.item),
-                    Promise.resolve(model.data)
-                ]);
-            }
-        })
-            .then(function (responses) {
-            // extract responses
-            var _a = __read(responses, 2), itemBase = _a[0], itemData = _a[1];
-            // sanitize all the things
-            var sanitizer = new common.Sanitizer();
-            var item = common.sanitizeJSONAndReportChanges(itemBase, sanitizer);
-            // TODO: we should delegate data sanization to the type-specific modules
-            var data = itemData;
-            // get the item id before it is deleted
-            var itemId = item.id;
-            // apply item props to deployOptions
-            deployOptions = updateDeployOptions(deployOptions, item, storageAuthentication);
-            // Clone before mutating? This was messing me up in some testing...
-            common.deleteItemProps(item);
-            return deploySolutionFromTemplate(itemId, item, data, authentication, deployOptions);
-        })
-            .then(function (createdSolutionId) {
-            /* istanbul ignore else */
-            if (deployOptions.progressCallback) {
-                deployOptions.progressCallback(100); // we're done
-            }
-            return createdSolutionId;
-        }, function (error) {
-            // Error deploying solution
-            /* istanbul ignore else */
-            if (deployOptions.progressCallback) {
-                deployOptions.progressCallback(1);
-            }
-            return Promise.reject(error);
-        })
-            .catch(function (ex) {
-            throw ex;
-        });
-    }
+  exports.UNSUPPORTED = UNSUPPORTED;
+  exports._createItemFromTemplateWhenReady = _createItemFromTemplateWhenReady;
+  exports._estimateDeploymentCost = _estimateDeploymentCost;
+  exports._evaluateSharedViewSources = _evaluateSharedViewSources;
+  exports._findExistingItem = _findExistingItem;
+  exports._findExistingItemByKeyword = _findExistingItemByKeyword;
+  exports._flagPatchItemsForPostProcessing = _flagPatchItemsForPostProcessing;
+  exports._getGroupUpdates = _getGroupUpdates;
+  exports._getViewHash = _getViewHash;
+  exports._getViews = _getViews;
+  exports._handleExistingItems = _handleExistingItems;
+  exports._isModel = _isModel;
+  exports._reuseDeployedItems = _reuseDeployedItems;
+  exports._setFields = _setFields;
+  exports._setTypekeywordForExisting = _setTypekeywordForExisting;
+  exports._updateTemplateDictionary = _updateTemplateDictionary;
+  exports._updateTemplateDictionaryById = _updateTemplateDictionaryById;
+  exports._updateTemplateDictionaryForError = _updateTemplateDictionaryForError;
+  exports._updateViewTemplates = _updateViewTemplates;
+  exports._useExistingItems = _useExistingItems;
+  exports.deploySolution = deploySolution;
+  exports.deploySolutionItems = deploySolutionItems;
+  exports.getSolutionTemplateItem = getSolutionTemplateItem;
+  exports.isSolutionTemplateItem = isSolutionTemplateItem;
+  exports.moduleMap = moduleMap;
+  exports.updateDeployOptions = updateDeployOptions;
 
-    exports.UNSUPPORTED = UNSUPPORTED;
-    exports._createItemFromTemplateWhenReady = _createItemFromTemplateWhenReady;
-    exports._estimateDeploymentCost = _estimateDeploymentCost;
-    exports._evaluateSharedViewSources = _evaluateSharedViewSources;
-    exports._findExistingItem = _findExistingItem;
-    exports._findExistingItemByKeyword = _findExistingItemByKeyword;
-    exports._flagPatchItemsForPostProcessing = _flagPatchItemsForPostProcessing;
-    exports._getGroupUpdates = _getGroupUpdates;
-    exports._getViewHash = _getViewHash;
-    exports._getViews = _getViews;
-    exports._handleExistingItems = _handleExistingItems;
-    exports._isModel = _isModel;
-    exports._reuseDeployedItems = _reuseDeployedItems;
-    exports._updateTemplateDictionary = _updateTemplateDictionary;
-    exports._updateTemplateDictionaryById = _updateTemplateDictionaryById;
-    exports._updateTemplateDictionaryForError = _updateTemplateDictionaryForError;
-    exports._updateViewTemplates = _updateViewTemplates;
-    exports._useExistingItems = _useExistingItems;
-    exports.deploySolution = deploySolution;
-    exports.deploySolutionItems = deploySolutionItems;
-    exports.getSolutionTemplateItem = getSolutionTemplateItem;
-    exports.isSolutionTemplateItem = isSolutionTemplateItem;
-    exports.moduleMap = moduleMap;
-    exports.updateDeployOptions = updateDeployOptions;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
+  Object.defineProperty(exports, '__esModule', { value: true });
 
 })));
 //# sourceMappingURL=deployer.umd.js.map