@esri/hub-common 9.13.2 → 9.16.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.13.1 - Sat Jan 22 2022 18:07:51 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.15.0 - Wed Feb 16 2022 20:36:25 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -2988,6 +2988,31 @@
         }
     }
 
+    /**
+     *   Dasherize a string
+     *
+     *  ```javascript
+     *  import { dasherize } from '@esri/hub-common';
+     *  dasherize('innerHTML');                // 'inner-html'
+     *  dasherize('action_name');              // 'action-name'
+     *  dasherize('css-class-name');           // 'css-class-name'
+     *  dasherize('my favorite items');        // 'my-favorite-items'
+     *  dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+     *  ```
+     *
+     *  Extracted and modified from Ember.js source code - MIT license
+     *  @param value
+     *  @returns
+     */
+    function dasherize(value) {
+        var DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+        var DASHERIZE_REGEXP = /[ _]/g;
+        return value
+            .replace(DECAMELIZE_REGEXP, "$1_$2")
+            .toLowerCase()
+            .replace(DASHERIZE_REGEXP, "-");
+    }
+
     /**
      * Checks for fundamental privilege required by all access checks
      * @param {IUser} user
@@ -3255,6 +3280,76 @@
         });
     }
 
+    /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * ```js
+     * import { createItemInFolder } from "@esri/arcgis-rest-portal";
+     * //
+     * createItemInFolder({
+     *   item: {
+     *     title: "The Amazing Voyage",
+     *     type: "Web Map"
+     *   },
+     *   folderId: 'fe8',
+     *   authentication
+     * })
+     * ```
+     * Create an item in a folder. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/add-item.htm) for more information.
+     *
+     * @param requestOptions = Options for the request
+     */
+    function createItemInFolder(requestOptions) {
+        if (requestOptions.multipart && !requestOptions.filename) {
+            return Promise.reject(new Error("The filename is required for a multipart request."));
+        }
+        return determineOwner(requestOptions).then(function (owner) {
+            var baseUrl = getPortalUrl$1(requestOptions) + "/content/users/" + owner;
+            var url = baseUrl + "/addItem";
+            if (requestOptions.folderId) {
+                url = baseUrl + "/" + requestOptions.folderId + "/addItem";
+            }
+            requestOptions.params = __assign(__assign({}, requestOptions.params), serializeItem(requestOptions.item));
+            // serialize the item into something Portal will accept
+            var options = appendCustomParams(requestOptions, [
+                "owner",
+                "folderId",
+                "file",
+                "dataUrl",
+                "text",
+                "async",
+                "multipart",
+                "filename",
+                "overwrite"
+            ], {
+                params: __assign({}, requestOptions.params)
+            });
+            return request(url, options);
+        });
+    }
+    /**
+     * ```js
+     * import { createItem } from "@esri/arcgis-rest-portal";
+     * //
+     * createItem({
+     *   item: {
+     *     title: "The Amazing Voyage",
+     *     type: "Web Map"
+     *   },
+     *   authentication
+     * })
+     * ```
+     * Create an Item in the user's root folder. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/add-item.htm) for more information.
+     *
+     * @param requestOptions - Options for the request
+     * @returns A Promise that creates an item.
+     */
+    function createItem(requestOptions) {
+        // delegate to createItemInFolder placing in the root of the filestore
+        var options = __assign({ folderId: null }, requestOptions);
+        return createItemInFolder(options);
+    }
+
     /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     /**
@@ -4976,6 +5071,52 @@
         return content.replace("(", "<br/>(");
     }
 
+    /**
+     * Cross-walk from a portalUrl to the corresponding Hub API Url
+     *
+     * If the passed url is not recognized, then this will return `undefined`
+     * @param portalUrl
+     * @returns
+     */
+    function getHubApiFromPortalUrl(portalUrl) {
+        var result;
+        if (portalUrl.match(/(qaext|\.mapsqa)\.arcgis.com/)) {
+            result = "https://hubqa.arcgis.com";
+        }
+        else if (portalUrl.match(/(devext|\.mapsdevext)\.arcgis.com/)) {
+            result = "https://hubdev.arcgis.com";
+        }
+        else if (portalUrl.match(/(www|\.maps)\.arcgis.com/)) {
+            result = "https://hub.arcgis.com";
+        }
+        return result;
+    }
+
+    /**
+     * Given an org url, get the portal base url
+     *
+     * i.e. https://myorg.maps.arcgis.com will return https://www.arcgis.com
+     *
+     * @param orgUrl
+     * @returns
+     */
+    function getPortalBaseFromOrgUrl(orgUrl) {
+        var result = orgUrl;
+        if (orgUrl.match(/(qaext|\.mapsqa)\.arcgis.com/)) {
+            result = "https://qaext.arcgis.com";
+        }
+        else if (orgUrl.match(/(devext|\.mapsdevext)\.arcgis.com/)) {
+            result = "https://devext.arcgis.com";
+        }
+        else {
+            /* istanbul ignore else */
+            if (orgUrl.match(/(www|\.maps)\.arcgis.com/)) {
+                result = "https://www.arcgis.com";
+            }
+        }
+        return result;
+    }
+
     var MAP_OR_FEATURE_SERVER_URL_REGEX = /\/(map|feature)server/i;
     /**
      *
@@ -5017,146 +5158,689 @@
         return _getHubUrlFromPortalHostname(getPortalApiUrl(urlOrObject));
     }
 
-    /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
-     * Apache-2.0 */
     /**
-     * A thin wrapper around [`UserSession.completeOAuth2()`](https://esri.github.io/arcgis-rest-js/api/auth/UserSession/#completeOAuth2) that sets search tags and other relevant metadata for newly created community users.
+     * Hash of Hub API end points so updates
+     * are centralized
      */
-    /* istanbul ignore next */
-    function completeOAuth2(options, win) {
-        if (win === void 0) { win = window; }
-        var match = win.location.href.match(/access_token=(.+)&expires_in=.+&username=([^&]+)/);
-        var token = match[1];
-        var user = decodeURIComponent(match[2]);
-        var baseUrl = "https://www.arcgis.com/sharing/rest/community/users/" + user;
-        return request(baseUrl, {
-            params: { token: token },
-            httpMethod: "GET"
-        }).then(function (response) {
-            if (Date.now() - response.created < 5000) {
-                return request(baseUrl + "/update", {
-                    params: {
-                        token: token,
-                        tags: ["hubRole:participant", "org:" + response.orgId],
-                        access: "public"
-                    }
-                }).then(function () {
-                    return UserSession.completeOAuth2(options);
-                });
+    var hubApiEndpoints = {
+        domains: "/api/v3/domains",
+        search: "/api/v3/datasets",
+        discussions: "/api/discussions/v1",
+    };
+    /**
+     * Abstraction that holds a `UserSession`, along with
+     * getters to streamline access to various platform
+     * urls, and common constructs like `IRequestOptions`,
+     * `IUserRequestOptions` etc.
+     *
+     * Instances are intended to be immutable, but this is not directly enforced.
+     *
+     * In most circumstances, this class should be created by
+     * the ArcGISContextManager class.
+     */
+    var ArcGISContext = /** @class */ (function () {
+        /**
+         * Create a new instance of `ArcGISContext`.
+         *
+         * @param opts
+         */
+        function ArcGISContext(opts) {
+            this._portalUrl = "https://www.arcgis.com";
+            this.id = opts.id;
+            this._portalUrl = opts.portalUrl;
+            this._hubUrl = opts.hubUrl;
+            if (opts.authentication) {
+                this._authentication = opts.authentication;
             }
-            else {
-                return UserSession.completeOAuth2(options);
+            if (opts.portalSelf) {
+                this._portalSelf = opts.portalSelf;
+            }
+            if (opts.currentUser) {
+                this._currentUser = opts.currentUser;
+            }
+            if (opts.properties) {
+                this._properties = opts.properties;
             }
+        }
+        Object.defineProperty(ArcGISContext.prototype, "session", {
+            /**
+             * Return the UserSession if authenticated
+             */
+            get: function () {
+                return this._authentication;
+            },
+            enumerable: false,
+            configurable: true
         });
-    }
-
-    var app$1 = [
-        "Application",
-        "City Engine Web Scene",
-        "CityEngine Web Scene",
-        "Dashboard",
-        "Insights Page",
-        "Insights Workbook",
-        "Operation View",
-        "Web Mapping Application",
-        "StoryMap",
-        "Web Experience",
-        "Urban Model",
-    ];
-    var dataset$1 = [
-        "CSV Collection",
-        "CSV",
-        "Feature Collection Template",
-        "Feature Collection",
-        "Feature Layer",
-        "Feature Service",
-        "File Geodatabase",
-        "GeoJSON",
-        "GeoJson",
-        "KML Collection",
-        "KML",
-        "Microsoft Excel",
-        "Raster Layer",
-        "Shapefile",
-        "Stream Service",
-        "Table",
-    ];
-    var document$1 = [
-        "CAD Drawing",
-        "Document Link",
-        "Hub Page",
-        "Site Page",
-        "Image",
-        "iWork Keynote",
-        "iWork Numbers",
-        "iWork Pages",
-        "Microsoft Powerpoint",
-        "Microsoft Visio",
-        "Microsoft Word",
-        "Notebook",
-        "PDF",
-        "Pro Map",
-        "Report Template",
-    ];
-    var event$1 = ["Hub Event"];
-    var feedback$1 = ["Form", "Quick Capture Project"];
-    var initiative$1 = ["Hub Initiative"];
-    var solution = ["Solution"];
-    var template = ["Hub Initiative Template"];
-    var map$1 = [
-        "Image Collection",
-        "Image Service",
-        "Map Service Layer",
-        "Map Service",
-        "Scene Service",
-        "Scene Layer",
-        "Vector Tile Service",
-        "Web Map Service",
-        "Web Map Tile Service",
-        "Web Map",
-        "Web Scene",
-        "WFS",
-        "WMS",
-        "WMTS",
-    ];
-    var other$1 = [
-        "360 VR Experience",
-        "AppBuilder Widget Package",
-        "Application Configuration",
-        "ArcPad Package",
-        "Code Attachment",
-        "Code Sample",
-        "Desktop Add In",
-        "Desktop Application Template",
-        "Desktop Application",
-        "Desktop Style",
-        "Explorer Add In",
-        "Explorer Layer",
-        "Geocoding Service",
-        "Geometry Service",
-        "Geoprocessing Package",
-        "Geoprocessing Sample",
-        "Geoprocessing Service",
-        "Layer File",
-        "Layer Package",
-        "Layer Template",
-        "Layer",
-        "Layout",
-        "Locator Package",
-        "Map Area",
-        "Map Document",
-        "Map Package",
-        "Map Service Definition",
-        "Map Template",
-        "Mobile Application",
-        "Mobile Map Package",
-        "Native Application",
-        "Network Analysis Service",
-        "Operations Dashboard Add In",
-        "Project Package",
-        "Project Template",
-        "Raster Function Template",
-        "Rule Package",
+        Object.defineProperty(ArcGISContext.prototype, "isAuthenticated", {
+            /**
+             * Return boolean indicating if authenticatio is present
+             */
+            get: function () {
+                return !!this._authentication;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "userRequestOptions", {
+            /**
+             * Return `IUserRequestOptions`, which is used for REST-JS
+             * functions which require authentication information.
+             *
+             * If context is not authenticated, this function will throw
+             */
+            get: function () {
+                if (this.isAuthenticated) {
+                    return {
+                        authentication: this._authentication,
+                        portal: this.sharingApiUrl,
+                    };
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "requestOptions", {
+            /**
+             * Return `IRequestOptions`, which is used by REST-JS functions
+             * which *may* use authentication information if provided.
+             *
+             * If context is not authenticated, this function just returns
+             * the `portal` property, which informs REST-JS what Sharing API
+             * instance to use (i.e. AGO, Enterprise etc)
+             */
+            get: function () {
+                var ro = {
+                    portal: this.sharingApiUrl,
+                };
+                if (this.isAuthenticated) {
+                    ro = {
+                        authentication: this._authentication,
+                        portal: this.sharingApiUrl,
+                    };
+                }
+                return ro;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "hubRequestOptions", {
+            /**
+             * Return a `IHubRequestOptions` object
+             */
+            get: function () {
+                // We may add more logic around what is returned in some corner cases
+                if (this.isAuthenticated) {
+                    return {
+                        authentication: this.session,
+                        isPortal: this.isPortal,
+                        portalSelf: this.portal,
+                        hubApiUrl: this.hubUrl,
+                    };
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "portalUrl", {
+            /**
+             * Return the portal url i.e. https://www.arcgis.com
+             *
+             * If authenticated @ ArcGIS Online, it will return
+             * the https://org.env.arcgis.com
+             *
+             * If authenticated @ ArcGIS Enterprise, it will return
+             * https://{portalHostname}/{webadaptor}
+             */
+            get: function () {
+                if (this.isAuthenticated) {
+                    if (this.isPortal) {
+                        return "https://" + this._portalSelf.portalHostname;
+                    }
+                    else {
+                        return "https://" + this._portalSelf.urlKey + "." + this._portalSelf.customBaseUrl;
+                    }
+                }
+                else {
+                    return this._portalUrl;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "sharingApiUrl", {
+            /**
+             * Returns the url to the sharing api composed from portalUrl
+             * i.e. https://myorg.maps.arcgis.com/sharing/rest
+             */
+            get: function () {
+                return this.portalUrl + "/sharing/rest";
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "hubUrl", {
+            /**
+             * Returns the Hub url, based on the portalUrl
+             *
+             * For ArcGIS Enterprise this will return `undefined`
+             */
+            get: function () {
+                return this._hubUrl;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "isPortal", {
+            /**
+             * Returns boolean indicating if the backing system
+             * is ArcGIS Enterprise (formerly ArcGIS Portal) or not
+             */
+            get: function () {
+                return this._portalSelf
+                    ? this._portalSelf.isPortal
+                    : this._portalUrl.indexOf("arcgis.com") === -1;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "discussionsServiceUrl", {
+            /**
+             * Returns the discussions API URL
+             */
+            get: function () {
+                if (this._hubUrl) {
+                    return "" + this._hubUrl + hubApiEndpoints.discussions;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "hubSearchServiceUrl", {
+            /**
+             * Returns the Hub Search API URL
+             */
+            get: function () {
+                if (this._hubUrl) {
+                    return "" + this._hubUrl + hubApiEndpoints.search;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "domainServiceUrl", {
+            /**
+             * Returns Hub Domain Service URL
+             */
+            get: function () {
+                if (this._hubUrl) {
+                    return "" + this._hubUrl + hubApiEndpoints.domains;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "eventsConfig", {
+            /**
+             * Returns the Events configuration object from portal/self
+             *
+             * `{serviceId: '3ef..', publicViewId: 'bc3...'}`
+             */
+            get: function () {
+                if (this._portalSelf) {
+                    return getProp(this._portalSelf, "portalProperties.hub.settings.events");
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "hubEnabled", {
+            /**
+             * Returns boolean indicating if the current user
+             * belongs to an organization that has licensed
+             * ArcGIS Hub
+             */
+            get: function () {
+                return getWithDefault$1(this._portalSelf, "portalProperties.hub.enabled", false);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "communityOrgId", {
+            /**
+             * Return the Hub Community Org Id, if defined
+             */
+            get: function () {
+                if (this._portalSelf) {
+                    return getProp(this._portalSelf, "portalProperties.hub.settings.communityOrg.orgId");
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "communityOrgHostname", {
+            /**
+             * Returns the Hub Community Org Hostname, if defined
+             *
+             * i.e. c-org.maps.arcgis.com
+             */
+            get: function () {
+                if (this._portalSelf) {
+                    return getProp(this._portalSelf, "portalProperties.hub.settings.communityOrg.portalHostname");
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "communityOrgUrl", {
+            /**
+             * Returns the Hub Community Org url
+             *
+             * i.e. https://c-org.maps.arcgis.com
+             */
+            get: function () {
+                if (this.communityOrgHostname) {
+                    return "https://" + this.communityOrgHostname;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "helperServices", {
+            /**
+             * Returns the hash of helper services from portal self
+             */
+            get: function () {
+                if (this._portalSelf) {
+                    return this._portalSelf.helperServices;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "currentUser", {
+            /**
+             * Returns the current user as IUser
+             */
+            get: function () {
+                return this._currentUser;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "portal", {
+            /**
+             * Returns the portal object as IPortal
+             */
+            get: function () {
+                return this._portalSelf;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(ArcGISContext.prototype, "properties", {
+            /**
+             * Return the properties hash that was passed in.
+             * Useful for app-specific context such as the active
+             * Site for ArcGIS Hub
+             */
+            get: function () {
+                return this._properties;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return ArcGISContext;
+    }());
+
+    /**
+     * The manager exposes context (`IArcGISContext`), which combines a `UserSession` with
+     * the `portal/self` and `user/self` responses to provide a central lookup for platform
+     * information, api urls, and other useful properties for developers such as IRequestOptions
+     * IUserRequestOptions, IHubRequestOptions etc.
+     *
+     * The context is exposed on gthe `.context` property, and as the authentication changes
+     * the `.context` is re-created. This is done to allow web frameworks to watch for
+     * changes on that single property, instead of having to leverage observers or events
+     * for change detection.
+     *
+     * Please see the [ArcGISContext Guide](/hub.js/guides/context) for additional information.
+     *
+     */
+    var ArcGISContextManager = /** @class */ (function () {
+        /**
+         * Private constructor. Use `ArcGISContextManager.create(...)` to
+         * instantiate an instance
+         * @param opts
+         */
+        function ArcGISContextManager(opts) {
+            this._portalUrl = "https://www.arcgis.com";
+            this._logLevel = exports.Level.error;
+            // Having a unique id makes debugging easier
+            this.id = new Date().getTime();
+            if (opts.logLevel) {
+                this._logLevel = opts.logLevel;
+            }
+            Logger.setLogLevel(this._logLevel);
+            Logger.debug("ArcGISContextManager:ctor: Creating " + this.id);
+            if (opts.properties) {
+                this._properties = opts.properties;
+            }
+            if (opts.authentication) {
+                this._authentication = opts.authentication;
+                this._portalUrl = this._authentication.portal.replace("/sharing/rest", "");
+                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
+            }
+            else if (opts.portalUrl) {
+                this._portalUrl = opts.portalUrl;
+                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
+            }
+            else {
+                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
+            }
+            if (opts.portal) {
+                this._portalSelf = cloneObject$1(opts.portal);
+            }
+            if (opts.currentUser) {
+                this._currentUser = cloneObject$1(opts.currentUser);
+            }
+        }
+        /**
+         * Used to create a new instance of the ArcGISContext class.
+         *
+         * ```js
+         * const ctxMgr = await ArcGISContextManager.create();
+         * ```
+         *
+         * @param opts
+         * @returns
+         */
+        ArcGISContextManager.create = function (opts) {
+            if (opts === void 0) { opts = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var ctx;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            ctx = new ArcGISContextManager(opts);
+                            return [4 /*yield*/, ctx.initialize()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, ctx];
+                    }
+                });
+            });
+        };
+        /**
+         * Set the Authentication (UserSession) for the context.
+         * This should be called when a user signs into a running
+         * application.
+         * @param auth
+         */
+        ArcGISContextManager.prototype.setAuthentication = function (auth) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this._authentication = auth;
+                            this._portalUrl = auth.portal.replace("/sharing/rest", "");
+                            return [4 /*yield*/, this.initialize()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Set the properties hash and re-create the context
+         * @param properties
+         */
+        ArcGISContextManager.prototype.setProperties = function (properties) {
+            this._properties = properties;
+            this._context = new ArcGISContext(this.contextOpts);
+        };
+        /**
+         * Clear the Authentication (UserSession). This should be
+         * called when a user signs out of an application, but
+         * the application continues running
+         */
+        ArcGISContextManager.prototype.clearAuthentication = function () {
+            // Reset the portalUrl from the org url to the base url
+            // for ArcGIS Enterprise, we just leave the _portalUrl as-is
+            if (!this._context.isPortal) {
+                this._portalUrl = getPortalBaseFromOrgUrl(this._portalUrl);
+            }
+            // Clear the auth, portalSelf and currentUser props
+            this._authentication = null;
+            this._portalSelf = null;
+            this._currentUser = null;
+            this._context = new ArcGISContext(this.contextOpts);
+        };
+        Object.defineProperty(ArcGISContextManager.prototype, "context", {
+            /**
+             * Return a reference to the current state.
+             * When `.setAuthentication()` or `.clearAuthenentication()` are
+             * called, the state will be re-created. This is done so frameworks
+             * like React or Ember can detect changes.
+             */
+            get: function () {
+                return this._context;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * If we have a UserSession, fetch portal/self and
+         * store that along with current user
+         */
+        ArcGISContextManager.prototype.initialize = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var username, requests, _a, portal, user, ex_1, msg;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!(this._authentication && (!this._portalSelf || !this._currentUser))) return [3 /*break*/, 4];
+                            Logger.debug("ArcGISContextManager-" + this.id + ": Initializing");
+                            username = this._authentication.username;
+                            requests = [
+                                getSelf({ authentication: this._authentication }),
+                                getUser({ username: username, authentication: this._authentication }),
+                            ];
+                            _b.label = 1;
+                        case 1:
+                            _b.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, Promise.all(requests)];
+                        case 2:
+                            _a = _b.sent(), portal = _a[0], user = _a[1];
+                            this._portalSelf = portal;
+                            this._currentUser = user;
+                            Logger.debug("ArcGISContextManager-" + this.id + ": received portalSelf and currentUser");
+                            return [3 /*break*/, 4];
+                        case 3:
+                            ex_1 = _b.sent();
+                            msg = "ArcGISContextManager could not fetch portal & user for \"" + this._authentication.username + "\" using " + this._authentication.portal + ".";
+                            Logger.error(msg);
+                            // tslint:disable-next-line:no-console
+                            console.error(msg);
+                            throw ex_1;
+                        case 4:
+                            Logger.debug("ArcGISContextManager-" + this.id + ": updating context");
+                            // update the context
+                            this._context = new ArcGISContext(this.contextOpts);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Object.defineProperty(ArcGISContextManager.prototype, "contextOpts", {
+            /**
+             * Getter to streamline the creation of updated Context instances
+             */
+            get: function () {
+                var contextOpts = {
+                    id: this.id,
+                    portalUrl: this._portalUrl,
+                    hubUrl: this._hubUrl,
+                    properties: this._properties,
+                };
+                if (this._authentication) {
+                    contextOpts.authentication = this._authentication;
+                }
+                if (this._portalSelf) {
+                    contextOpts.portalSelf = this._portalSelf;
+                }
+                if (this._currentUser) {
+                    contextOpts.currentUser = this._currentUser;
+                }
+                return contextOpts;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return ArcGISContextManager;
+    }());
+
+    /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * A thin wrapper around [`UserSession.completeOAuth2()`](https://esri.github.io/arcgis-rest-js/api/auth/UserSession/#completeOAuth2) that sets search tags and other relevant metadata for newly created community users.
+     */
+    /* istanbul ignore next */
+    function completeOAuth2(options, win) {
+        if (win === void 0) { win = window; }
+        var match = win.location.href.match(/access_token=(.+)&expires_in=.+&username=([^&]+)/);
+        var token = match[1];
+        var user = decodeURIComponent(match[2]);
+        var baseUrl = "https://www.arcgis.com/sharing/rest/community/users/" + user;
+        return request(baseUrl, {
+            params: { token: token },
+            httpMethod: "GET"
+        }).then(function (response) {
+            if (Date.now() - response.created < 5000) {
+                return request(baseUrl + "/update", {
+                    params: {
+                        token: token,
+                        tags: ["hubRole:participant", "org:" + response.orgId],
+                        access: "public"
+                    }
+                }).then(function () {
+                    return UserSession.completeOAuth2(options);
+                });
+            }
+            else {
+                return UserSession.completeOAuth2(options);
+            }
+        });
+    }
+
+    var app$1 = [
+        "Application",
+        "City Engine Web Scene",
+        "CityEngine Web Scene",
+        "Dashboard",
+        "Insights Page",
+        "Insights Workbook",
+        "Operation View",
+        "Web Mapping Application",
+        "StoryMap",
+        "Web Experience",
+        "Urban Model",
+    ];
+    var dataset$1 = [
+        "CSV Collection",
+        "CSV",
+        "Feature Collection Template",
+        "Feature Collection",
+        "Feature Layer",
+        "Feature Service",
+        "File Geodatabase",
+        "GeoJSON",
+        "GeoJson",
+        "KML Collection",
+        "KML",
+        "Microsoft Excel",
+        "Raster Layer",
+        "Shapefile",
+        "Stream Service",
+        "Table",
+    ];
+    var document$1 = [
+        "CAD Drawing",
+        "Document Link",
+        "Hub Page",
+        "Site Page",
+        "Image",
+        "iWork Keynote",
+        "iWork Numbers",
+        "iWork Pages",
+        "Microsoft Powerpoint",
+        "Microsoft Visio",
+        "Microsoft Word",
+        "Notebook",
+        "PDF",
+        "Pro Map",
+        "Report Template",
+    ];
+    var event$1 = ["Hub Event"];
+    var feedback$1 = ["Form", "Quick Capture Project"];
+    var initiative$1 = ["Hub Initiative"];
+    var solution = ["Solution"];
+    var template = ["Hub Initiative Template"];
+    var map$1 = [
+        "Image Collection",
+        "Image Service",
+        "Map Service Layer",
+        "Map Service",
+        "Scene Service",
+        "Scene Layer",
+        "Vector Tile Service",
+        "Web Map Service",
+        "Web Map Tile Service",
+        "Web Map",
+        "Web Scene",
+        "WFS",
+        "WMS",
+        "WMTS",
+    ];
+    var other$1 = [
+        "360 VR Experience",
+        "AppBuilder Widget Package",
+        "Application Configuration",
+        "ArcPad Package",
+        "Code Attachment",
+        "Code Sample",
+        "Desktop Add In",
+        "Desktop Application Template",
+        "Desktop Application",
+        "Desktop Style",
+        "Explorer Add In",
+        "Explorer Layer",
+        "Geocoding Service",
+        "Geometry Service",
+        "Geoprocessing Package",
+        "Geoprocessing Sample",
+        "Geoprocessing Service",
+        "Layer File",
+        "Layer Package",
+        "Layer Template",
+        "Layer",
+        "Layout",
+        "Locator Package",
+        "Map Area",
+        "Map Document",
+        "Map Package",
+        "Map Service Definition",
+        "Map Template",
+        "Mobile Application",
+        "Mobile Map Package",
+        "Native Application",
+        "Network Analysis Service",
+        "Operations Dashboard Add In",
+        "Project Package",
+        "Project Template",
+        "Raster Function Template",
+        "Rule Package",
         "Scene Package",
         "Service Definition",
         "SQLite Geodatabase",
@@ -5166,6 +5850,8 @@
         "Workflow Manager Package",
     ];
     var site$1 = ["Hub Site Application", "Site Application"];
+    // TODO: remove this at the next breaking change
+    // it's only here to support deprecated categories
     var collections = {
         app: app$1,
         dataset: dataset$1,
@@ -5742,7 +6428,22 @@
             geometry: geometry,
         };
     };
+    var MAX_SIZE = 5000000;
+    /**
+     * Returns whether or not an item is a proxied csv
+     *
+     * @param item
+     * @param requestOptions Hub Request Options (including whether we're in portal)
+     * @returns
+     */
+    var isProxiedCSV = function (item, requestOptions) {
+        return !requestOptions.isPortal &&
+            item.access === "public" &&
+            item.type === "CSV" &&
+            item.size <= MAX_SIZE;
+    };
 
+    // private helper functions
     function collectionToFamily(collection) {
         var overrides = {
             other: "content",
@@ -6349,7 +7050,7 @@
     }
     /**
      * returns a new content that has the specified type and
-     * and updated related properties like normalizedType, family, etc
+     * and updated related properties like, family, etc
      * @param content orignal content
      * @param type new type
      * @returns new content
@@ -6360,9 +7061,8 @@
         var family = getFamily(normalizedType);
         var contentTypeIcon = getContentTypeIcon(normalizedType);
         var contentTypeLabel = getContentTypeLabel(normalizedType, content.isProxied);
-        // TODO: don't we need to update content.item.type too?
-        var updated = __assign(__assign({}, content), { type: type,
-            family: family,
+        var updated = __assign(__assign({}, content), { type: normalizedType, family: family,
+            // TODO: remove this at next breaking change now that it has been deprecated
             normalizedType: normalizedType,
             contentTypeIcon: contentTypeIcon,
             contentTypeLabel: contentTypeLabel });
@@ -6373,23 +7073,26 @@
         });
     };
     /**
-     * Compute the content type icon based on the normalizedType
-     * @param normalizedType
+     * Compute the content type icon based on the content type
+     * @param content type
      * @returns content type icon
      */
-    var getContentTypeIcon = function (normalizedType) {
+    var getContentTypeIcon = function (contentType) {
         var _a;
-        var type = camelize(normalizedType || "");
+        var type = camelize(contentType || "");
         var iconMap = {
             appbuilderExtension: "file",
             appbuilderWidgetPackage: "widgets-source",
             application: "web",
+            applicationConfiguration: "app-gear",
             arcgisProMap: "desktop",
             cadDrawing: "file-cad",
             cityEngineWebScene: "urban-model",
             codeAttachment: "file-code",
+            codeSample: "file-code",
             colorSet: "palette",
             contentCategorySet: "label",
+            csv: "file-csv",
             cSV: "file-csv",
             cSVCollection: "file-csv",
             dashboard: "dashboard",
@@ -6411,8 +7114,8 @@
             geoprocessingService: "file",
             globeLayer: "layers",
             globeService: "file",
-            hubInitiative: "mountain-summit-nocap",
-            hubInitiativeTemplate: "initiative-template-outlines-thick",
+            hubInitiative: "initiative",
+            hubInitiativeTemplate: "initiative-template",
             hubPage: "browser",
             hubSiteApplication: "web",
             image: "file-image",
@@ -6428,6 +7131,7 @@
             kMLCollection: "data",
             layer: "layers",
             layerPackage: "layers",
+            layerTemplate: "file",
             locatorPackage: "file",
             mapArea: "file",
             mapDocument: "map-contents",
@@ -6450,6 +7154,7 @@
             orthoMappingTemplate: "file",
             pDF: "file-pdf",
             quickCaptureProject: "mobile",
+            rasterFunctionTemplate: "file",
             rasterLayer: "map",
             realTimeAnalytic: "file",
             relationalDatabaseConnection: "file",
@@ -6458,19 +7163,23 @@
             sceneService: "urban-model",
             serviceDefinition: "file",
             shapefile: "data",
-            solution: "solutions",
+            solution: "puzzle-piece",
             sqliteGeodatabase: "file",
             statisticalDataCollection: "file",
+            storymap: "tour",
             storyMap: "tour",
+            storymapTheme: "palette",
             symbolSet: "file",
             table: "table",
             urbanModel: "urban-model",
+            vectorTilePackage: "file-shape",
             vectorTileService: "map",
             visioDocument: "conditional-rules",
             webExperience: "apps",
             webMap: "map",
             webMappingApplication: "apps",
             webScene: "urban-model",
+            wfs: "map",
             wFS: "map",
             wMS: "map",
             wMTS: "map",
@@ -6481,12 +7190,12 @@
     };
     /**
      * Compute the content type label
-     * @param normalizedType
+     * @param contentType
      * @param isProxied
      * @returns content type label
      */
-    var getContentTypeLabel = function (normalizedType, isProxied) {
-        return isProxied ? "CSV" : camelize(normalizedType || "");
+    var getContentTypeLabel = function (contentType, isProxied) {
+        return isProxied ? "CSV" : camelize(contentType || "");
     };
     /**
      * returns a new content that has the specified hubId and updated identifier
@@ -6579,8 +7288,8 @@
     var getSolutionUrl = function (content) {
         var _a;
         var hubUrl;
-        var normalizedType = content.normalizedType, identifier = content.identifier;
-        if (normalizedType === "Solution") {
+        var type = content.type, identifier = content.identifier;
+        if (type === "Solution") {
             // NOTE: as per the above spreadsheet,
             // solution types are now in the Template family
             // but we don't send them to the route for initiative templates
@@ -6597,10 +7306,25 @@
     // TODO: we check both "Hub Page" and "Site Page" because we don't know whether the site is a portal or not
     // In the future, the site object will have a site.isPortal() function that we can leverage
     // instead of hardcoding the types here.
-    // TODO: should this be based on normalizedType instead?
     var isPageContent = function (content) {
         return includes(["Hub Page", "Site Page"], content.type);
     };
+    // proxied csv helpers
+    /**
+     * If an item is a proxied csv, returns the url for the proxying feature layer.
+     * If the item is not a proxied csv, returns undefined.
+     *
+     * @param item
+     * @param requestOptions Hub Request Options (including whether we're in portal)
+     * @returns
+     */
+    var getProxyUrl = function (item, requestOptions) {
+        var result;
+        if (isProxiedCSV(item, requestOptions)) {
+            result = requestOptions.hubApiUrl + "/datasets/" + item.id + "_0/FeatureServer/0";
+        }
+        return result;
+    };
 
     /**
      * Implementation of atob() according to the HTML and Infra specs, except that
@@ -7273,6 +7997,111 @@
             .then(_consolidateResults);
     }
 
+    /**
+     * Locales supported by the hub
+     */
+    var HUB_LOCALES = [
+        "ar",
+        "bs",
+        "ca",
+        "cs",
+        "da",
+        "de",
+        "en",
+        "es",
+        "et",
+        "el",
+        "fi",
+        "fr",
+        "hr",
+        "he",
+        "hu",
+        "it",
+        "id",
+        "ja",
+        "ko",
+        "lt",
+        "lv",
+        "nb",
+        "nl",
+        "pl",
+        "pt",
+        "pt-br",
+        "pt-pt",
+        "ro",
+        "ru",
+        "sl",
+        "sr",
+        "sv",
+        "th",
+        "tr",
+        "uk",
+        "vi",
+        "zh",
+        "zh-cn",
+        "zh-tw",
+        "zh-hk"
+    ];
+
+    /**
+     * Convert a requested locale into a locale we support.
+     * i.e. en-ca => en
+     * If the requested locale is not available, en will be returned
+     * @param {string} requestedLocale Locale we want
+     */
+    function convertToWellKnownLocale(requestedLocale) {
+        if (requestedLocale === void 0) { requestedLocale = "en"; }
+        var wellKnownKey = "en";
+        // ensure downcase
+        requestedLocale = requestedLocale.toLowerCase();
+        // see if it's in the hub translations as-is
+        if (HUB_LOCALES.indexOf(requestedLocale) > -1) {
+            wellKnownKey = requestedLocale;
+        }
+        else {
+            // if we split the requested locale, see if we have the root in the list
+            var parts = requestedLocale.split("-");
+            if (parts.length > 1 && HUB_LOCALES.indexOf(parts[0]) > -1) {
+                wellKnownKey = parts[0];
+            }
+        }
+        return wellKnownKey;
+    }
+
+    /**
+     * Fetch the Hub translation file for a given locale
+     * These are all public urls and should never require auth/tokens etc
+     * @param {String} locale Locale code - i.e. `es`
+     * @param {Object} portal Portal Self
+     */
+    function fetchHubTranslation(locale, portal, mode) {
+        if (mode === void 0) { mode = "cors"; }
+        var assetBase = getHubLocaleAssetUrl(portal);
+        var url = (assetBase + "/locales/" + locale + ".json").toLocaleLowerCase();
+        // to support web-tier auth, we must always send same-origin credentials
+        var options = {
+            method: "GET",
+            credentials: "same-origin",
+            mode: mode
+        };
+        return fetch(url, options)
+            .then(function (response) { return response.json(); })
+            .catch(function (err) {
+            throw Error("Attempt to fetch locale " + locale + " from " + url + " failed: " + JSON.stringify(err));
+        });
+    }
+
+    /**
+     * Return the culture from the Hub Request Options
+     * In priority order: user.culture, portal.culture, en-us
+     * @param {IHubRequestOptions} hubRequestOptions
+     */
+    function getCulture(hubRequestOptions) {
+        return (getProp(hubRequestOptions, "portalSelf.user.culture") ||
+            getProp(hubRequestOptions, "portalSelf.culture") ||
+            "en-us");
+    }
+
     /**
      * Unprotect and Remove an Item
      * Assumes caller has checked that the curernt user should be able to
@@ -7346,29 +8175,106 @@
     function failSafeUpdate(model, requestOptions) {
         var failSafedUpdate = failSafe(updateItem, {
             id: model.item.id,
-            success: true
+            success: true,
         });
         var opts = Object.assign({ item: serializeModel(model) }, requestOptions);
         return failSafedUpdate(opts);
     }
 
     /**
-     * Gets the full item/data model for an item
-     * @param {string} id Id of the item to fetch
+     * Gets the full item/data model for an item id
+     * @param {string} id
      * @param {Object} requestOptions
      */
     function getModel(id, requestOptions) {
         return Promise.all([
             getItem(id, requestOptions),
-            getItemData(id, requestOptions)
+            getItemData(id, requestOptions),
         ]).then(function (result) {
             // shape this into a model
             return {
                 item: result[0],
-                data: result[1]
+                data: result[1],
             };
         });
     }
+    /**
+     * Get a model by it's slug
+     *
+     * This uses the [Filter](https://developers.arcgis.com/rest/users-groups-and-items/search-reference.htm) option of the
+     * to search for an item that has a typekeyword of `slug|{slug-value}`
+     *
+     * This is useful for applications that want to use human-readable urls instead
+     * of using item ids.
+     *
+     * @param slug
+     * @param requestOptions
+     * @returns
+     */
+    function getModelBySlug(slug, requestOptions) {
+        return getItemBySlug(slug, requestOptions)
+            .then(function (item) {
+            var prms = [Promise.resolve(item)];
+            if (item) {
+                prms.push(getItemData(item.id, requestOptions));
+            }
+            else {
+                prms.push(Promise.resolve(null));
+            }
+            return Promise.all(prms);
+        })
+            .then(function (result) {
+            if (result[0]) {
+                return {
+                    item: result[0],
+                    data: result[1],
+                };
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    /**
+     * Create an item to back and IModel.
+     *
+     * @param {IModel}
+     * @param {IRequestOptions} requestOptions
+     * @returns {Promise<IModel>}
+     */
+    function createModel(model, requestOptions) {
+        var clone = cloneObject$1(model);
+        var item = cloneObject$1(model.item);
+        item.data = cloneObject$1(model.data);
+        var opts = __assign({ item: item }, requestOptions);
+        return createItem(opts).then(function (response) {
+            clone.item.id = response.id;
+            clone.item.created = new Date().getTime();
+            clone.item.modified = clone.item.created;
+            return clone;
+        });
+    }
+    /**
+     * Update an IModel. Generic function that will be used across all
+     * type-specific update functions
+     *
+     * @export
+     * @param {IModel} "model" object (i.e. `{item:{...}, data:{...}}`)
+     * @param {IRequestOptions} requestOptions
+     * @returns {Promise<IModel>}
+     */
+    function updateModel(model, requestOptions) {
+        var clone = cloneObject$1(model);
+        var item = cloneObject$1(model.item);
+        item.data = cloneObject$1(model.data);
+        var opts = __assign({ item: item }, requestOptions);
+        return updateItem(opts).then(function () {
+            // update the modified prop
+            // this won't be exact, but it will be very close
+            clone.item.modified = new Date().getTime();
+            return clone;
+        });
+    }
 
     /**
      * To streamline passing of either a model id or the model itself, we use this function
@@ -7389,7 +8295,7 @@
             if (options[idProp]) {
                 var failSafeModel = failSafe(getModel, {
                     item: { id: options[idProp] },
-                    isMissing: true
+                    isMissing: true,
                 });
                 return failSafeModel(options[idProp], options);
             }
@@ -7938,6 +8844,262 @@
         return interpolate(model, settings, transforms);
     }
 
+    /**
+     * Replaces instances of item ids on an item model
+     * @param {Object} obj Object graph to traverse
+     * @param {string} itemId id to replace with `{{appid}}`
+     */
+    function replaceItemId(obj, itemId, replacement) {
+        if (replacement === void 0) { replacement = "{{appid}}"; }
+        var clone = cloneObject$1(obj);
+        var re = new RegExp(itemId, "g");
+        return deepStringReplace(clone, re, replacement);
+    }
+
+    /**
+     * Share an item to a set of groups
+     * @param {String} itemId Iten Id to share to the groups
+     * @param {Array} groups Array of group id's to which the item will be shared
+     * @param {String} owner optional Owner username to determine which endpoint to hit
+     * @param {*} requestOptions
+     */
+    function shareItemToGroups(itemId, groups, requestOptions, owner) {
+        return Promise.all(groups.map(function (groupId) {
+            var opt = Object.assign({}, { id: itemId, groupId: groupId }, requestOptions);
+            if (owner) {
+                opt.owner = owner;
+            }
+            return shareItemWithGroup(opt);
+        }));
+    }
+
+    /**
+     * Given a model, determine if it is protected, and unprotect it if it is.
+     * Otherwise, just resolve with the same result.
+     * @param {Object} model Model Object
+     * @param {IRequestOptions} requestOptions
+     */
+    function unprotectModel(model, requestOptions) {
+        if (model.item.protected) {
+            var opts = Object.assign({ id: model.item.id }, requestOptions);
+            return unprotectItem(opts);
+        }
+        else {
+            // act as though we did it
+            return Promise.resolve({ success: true });
+        }
+    }
+
+    /**
+     * Unshare an item from a set of groups
+     * @param {String} itemId Item Id to unshare from groups
+     * @param {Array} groups Array of group id's from which the item will be unshared
+     * @param {String} owner optional Owner username to determine which endpoint to hit
+     * @param {IRequestOptions} requestOptions
+     */
+    function unshareItemFromGroups(itemId, groups, requestOptions, owner) {
+        return Promise.all(groups.map(function (groupId) {
+            var opt = Object.assign({}, { id: itemId, groupId: groupId }, requestOptions);
+            if (owner) {
+                opt.owner = owner;
+            }
+            return unshareItemWithGroup(opt);
+        }));
+    }
+
+    /**
+     * Check if a site/page exists with a specific name
+     */
+    function doesItemExistWithTitle(itemTitle, options, authMgr) {
+        // if options have multiple properties, put them into one string separated with 'AND'
+        var optionsQuery = Object.keys(options)
+            .map(function (key) {
+            return key + ":\"" + options[key] + "\"";
+        })
+            .join(" AND ");
+        var opts = {
+            q: "title:\"" + itemTitle + "\" AND " + optionsQuery,
+            authentication: authMgr
+        };
+        return searchItems(opts)
+            .then(function (searchResponse) { return searchResponse.results.length > 0; })
+            .catch(function (e) {
+            throw Error("Error in doesItemExistWithTitle " + e);
+        });
+    }
+
+    /**
+     * Given a title, construct a site/page title that is unique
+     * if that title exists, this fn will add a number on the end, and increment until
+     * an available title is found
+     * @param {string} title site/page title to ensure if unique
+     * @param {object} options an object that can be passed in to the q, eg. typekeywords, type
+     * @param {object} authMgr auth info tells the function what url to use for the "root" of the API,
+     * if missing, it will search against PROD
+     * @param {number} step Number to increment. Defaults to 0
+     */
+    function getUniqueItemTitle(title, options, authMgr, step) {
+        if (step === void 0) { step = 0; }
+        var combinedName = title;
+        if (step) {
+            combinedName = title + " " + step;
+        }
+        return doesItemExistWithTitle(combinedName, options, authMgr)
+            .then(function (result) {
+            if (result) {
+                step++;
+                return getUniqueItemTitle(title, options, authMgr, step);
+            }
+            else {
+                return combinedName;
+            }
+        })
+            .catch(function (e) {
+            throw Error("Error in getUniqueItemTitle " + e);
+        });
+    }
+
+    var MAX_NUM = 100;
+    /**
+     * Fetches all the pages in a search request
+     * @param {SearchFunction} searchFunc
+     * @param {ISearchOptions} opts
+     * @param {number} limit
+     * @param {batchSize} number of concurrent requests at a time
+     * @returns {Promise<SearchableType[]>}
+     */
+    function fetchAllPages(searchFunc, opts, limit, batchSize) {
+        if (limit === void 0) { limit = -1; }
+        var pageSize = opts.num || MAX_NUM;
+        var firstStart = opts.start || 1;
+        // If a limit is provided, we don't have to use the first request to get the
+        // total count before sending things off to batch(). So instead we fake the first
+        // response just to set things up.
+        var promise = limit === -1
+            ? searchFunc(__assign(__assign({}, opts), { num: pageSize, start: firstStart }))
+            : Promise.resolve({
+                nextStart: firstStart,
+                total: limit,
+                results: [],
+                num: pageSize
+            });
+        return promise
+            .then(function (firstResponse) {
+            // no more requests needed, return the first response
+            if (firstResponse.nextStart === -1)
+                return [firstResponse];
+            // generate batch requests for the remaining pages to fetch
+            var starts = [];
+            for (var i = firstResponse.nextStart; i <= firstResponse.total; i += pageSize) {
+                starts.push(i);
+            }
+            var batchSearchFunc = function (start) {
+                return searchFunc(__assign(__assign({}, opts), { start: start, num: pageSize }));
+            };
+            return batch(starts, batchSearchFunc, batchSize).then(function (responses) { return __spreadArrays([
+                firstResponse
+            ], responses); });
+        })
+            .then(function (responses) {
+            // merge all the search results into a single array
+            var results = responses.reduce(function (acc, response) { return __spreadArrays(acc, response.results); }, []);
+            // discard results beyond the limit if applicable
+            var clipLimit = limit === -1 ? results.length : limit;
+            return results.slice(0, clipLimit);
+        });
+    }
+
+    // TODO: work out how to unify content slug fns
+    // https: github.com/Esri/hub.js/blob/master/packages/common/src/content/index.ts#L301-L348
+    /**
+     * Create a slug, namespaced to an org
+     * Typically used to lookup items by a human readable name in urls
+     *
+     * @param title
+     * @param orgKey
+     * @returns
+     */
+    function constructSlug(title, orgKey) {
+        return orgKey.toLowerCase() + "-" + slugify(title);
+    }
+    /**
+     * Adds/Updates the slug typekeyword
+     * Returns a new array of keywords
+     * @param typeKeywords
+     * @param slug
+     * @returns
+     */
+    function setSlugKeyword(typeKeywords, slug) {
+        // remove slug entry from array
+        var removed = typeKeywords.filter(function (entry) {
+            return !entry.startsWith("slug|");
+        });
+        // now add it
+        removed.push("slug|" + slug);
+        return removed;
+    }
+    /**
+     * Get an item by searching for items with a typeKeyword like `slug|{slug-value}`
+     *
+     * For example, if you pass a slug `"snow-map"` into this function, it will
+     * search for items with `slug|snow-map` in it's typeKeywords array,
+     *
+     * @param slug
+     * @param requestOptions
+     * @returns
+     */
+    function getItemBySlug(slug, requestOptions) {
+        var opts = {
+            q: "",
+            filter: "typekeywords:\"slug|" + slug + "\"",
+            authentication: requestOptions.authentication,
+        };
+        return searchItems(opts)
+            .then(function (response) {
+            if (response.results.length) {
+                return response.results[0];
+            }
+            else {
+                return null;
+            }
+        })
+            .catch(function (e) {
+            throw Error("Error in getItemBySlug " + e);
+        });
+    }
+    /**
+     * Given a slug, search for items using that slug, incrementing the slug name until
+     * a unique value is found
+     *
+     * For example, if a slug of `"snow-map"` into this function and some item exists
+     * with that slug, it would return `"snow-map-1"`.
+     *
+     * @param slug
+     * @param requestOptions
+     * @param step
+     * @returns
+     */
+    function getUniqueSlug(slug, requestOptions, step) {
+        if (step === void 0) { step = 0; }
+        var combined = slug;
+        if (step) {
+            combined = slug + "-" + step;
+        }
+        return getItemBySlug(combined, requestOptions)
+            .then(function (result) {
+            if (result) {
+                step++;
+                return getUniqueSlug(slug, requestOptions, step);
+            }
+            else {
+                return combined;
+            }
+        })
+            .catch(function (e) {
+            throw Error("Error in getUniqueSlug " + e);
+        });
+    }
+
     var itemPropsNotInTemplates = [
         "id",
         "isOrgItem",
@@ -7967,182 +9129,529 @@
         "largeThumbnail"
     ];
     /**
-     * Given an item, remove a standard set of properties not needed in a template
-     * TODO: This should land in a templating helper lib in hub.js
-     * @param {Object} item Item to be normalized
+     * Given an item, remove a standard set of properties not needed in a template
+     * TODO: This should land in a templating helper lib in hub.js
+     * @param {Object} item Item to be normalized
+     */
+    function normalizeSolutionTemplateItem(item) {
+        var template = cloneObject$1(item);
+        itemPropsNotInTemplates.forEach(function (prop) {
+            delete template[prop];
+        });
+        // set a bunch of things we do want
+        template.extent = "{{organization.defaultExtentBBox}}";
+        return template;
+    }
+
+    /**
+     * Manage forward and backward property mappings to
+     * streamline conversion between the Hub entities, and
+     * the backing IModel
+     */
+    var PropertyMapper = /** @class */ (function () {
+        /**
+         * Pass in the mappings between the Entity and
+         * it's backing structure (model or otherwise)
+         * @param mappings
+         */
+        function PropertyMapper(mappings) {
+            this.mappings = mappings;
+        }
+        /**
+         * Map properties from a model on to the entity object.
+         *
+         * Used when constructing an entity can from a fetched model,
+         * in which case the entity should be an empty object (`{}`).
+         *
+         * Can also be used to apply changes to an entity from a model,
+         * in which case an existing entity can be passed in.
+         * @param model
+         * @param object
+         * @returns
+         */
+        PropertyMapper.prototype.modelToObject = function (model, object) {
+            return mapModelToObject(model, object, this.mappings);
+        };
+        /**
+         * Map properties from an entity object onto a model.
+         *
+         * Typically the model will already exist, and this
+         * method is used to transfer changes to the model
+         * prior to storage.
+         * @param object
+         * @param model
+         * @returns
+         */
+        PropertyMapper.prototype.objectToModel = function (object, model) {
+            return mapObjectToModel(object, model, this.mappings);
+        };
+        return PropertyMapper;
+    }());
+    /**
+     * Generic function to apply properties from an Object
+     * (i.e. IHubProject) onto a Model that can be persisted to an Item
+     * @param object
+     * @param model
+     * @param mappings
+     * @returns
+     */
+    function mapObjectToModel(object, model, mappings) {
+        return mapProps(object, "objectKey", model, "modelKey", mappings);
+    }
+    /**
+     * Generic function to apply properties from a Model
+     * onto an Object (i.e. IHubProject etc)
+     * @param model
+     * @param object
+     * @param mappings
+     * @returns
+     */
+    function mapModelToObject(model, object, mappings) {
+        return mapProps(model, "modelKey", object, "objectKey", mappings);
+    }
+    /**
+     * Internal function to map between objects
+     * @param source
+     * @param sourceKey
+     * @param target
+     * @param targetKey
+     * @param mappings
+     * @returns
      */
-    function normalizeSolutionTemplateItem(item) {
-        var template = cloneObject$1(item);
-        itemPropsNotInTemplates.forEach(function (prop) {
-            delete template[prop];
+    function mapProps(source, sourceKey, target, targetKey, mappings) {
+        // clone the target
+        var clone = cloneObject$1(target);
+        // walk the property map array
+        mappings.forEach(function (entry) {
+            // Verbose b/c typescript hates the use of property indexing with generics
+            // i.e. entry<T>[sourceKey] make typescript angry
+            var sourcePath = getProp(entry, sourceKey);
+            var targetPath = getProp(entry, targetKey);
+            // get the value from the source
+            var sourceVal = getProp(source, sourcePath);
+            // if it's not null or undefined
+            if (sourceVal !== null && sourceVal !== undefined) {
+                // set it
+                deepSet(clone, targetPath, sourceVal);
+            }
         });
-        // set a bunch of things we do want
-        template.extent = "{{organization.defaultExtentBBox}}";
-        return template;
+        return clone;
     }
 
+    var HUB_PROJECT_ITEM_TYPE = "Web Mapping Application";
     /**
-     * Replaces instances of item ids on an item model
-     * @param {Object} obj Object graph to traverse
-     * @param {string} itemId id to replace with `{{appid}}`
+     * Default values of a IHubProject
      */
-    function replaceItemId(obj, itemId, replacement) {
-        if (replacement === void 0) { replacement = "{{appid}}"; }
-        var clone = cloneObject$1(obj);
-        var re = new RegExp(itemId, "g");
-        return deepStringReplace(clone, re, replacement);
+    var DEFAULT_PROJECT = {
+        name: "No title provided",
+        tags: [],
+        typeKeywords: ["IHubProject", "HubProject"],
+    };
+    /**
+     * Default values for a new HubProject Model
+     */
+    var DEFAULT_PROJECT_MODEL = {
+        item: {
+            type: HUB_PROJECT_ITEM_TYPE,
+            title: "No Title Provided",
+            description: "No Description Provided",
+            snippet: "",
+            tags: [],
+            typeKeywords: [],
+            properties: {
+                slug: "",
+            },
+        },
+        data: {
+            display: "about",
+            timeline: {},
+            org: {},
+            status: "inactive",
+            contacts: [],
+            schemaVersion: 1,
+        },
+    };
+    /**
+     * Returns an Array of IPropertyMap objects
+     * We could define these directly, but since the
+     * properties of IHubProject map directly to properties
+     * on item or data, it's slightly less verbose to
+     * generate the structure.
+     * @returns
+     */
+    function getProjectPropertyMap() {
+        var itemProps = [
+            "created",
+            "culture",
+            "description",
+            "extent",
+            "id",
+            "modified",
+            "owner",
+            "snippet",
+            "tags",
+            "typeKeywords",
+            "url",
+            "type",
+        ];
+        var dataProps = [
+            "contacts",
+            "display",
+            "geometry",
+            "headerImage",
+            "layout",
+            "location",
+            "status",
+        ];
+        var map = [];
+        itemProps.forEach(function (entry) {
+            map.push({ objectKey: entry, modelKey: "item." + entry });
+        });
+        dataProps.forEach(function (entry) {
+            map.push({ objectKey: entry, modelKey: "data." + entry });
+        });
+        // Deeper mappings
+        map.push({
+            objectKey: "slug",
+            modelKey: "item.properties.slug",
+        });
+        map.push({
+            objectKey: "orgUrlKey",
+            modelKey: "item.properties.orgUrlKey",
+        });
+        map.push({
+            objectKey: "name",
+            modelKey: "item.title",
+        });
+        return map;
     }
-
     /**
-     * Share an item to a set of groups
-     * @param {String} itemId Iten Id to share to the groups
-     * @param {Array} groups Array of group id's to which the item will be shared
-     * @param {String} owner optional Owner username to determine which endpoint to hit
-     * @param {*} requestOptions
+     * Create a new Hub Project item
+     *
+     * Minimal properties are name and org
+     *
+     * @param project
+     * @param requestOptions
      */
-    function shareItemToGroups(itemId, groups, requestOptions, owner) {
-        return Promise.all(groups.map(function (groupId) {
-            var opt = Object.assign({}, { id: itemId, groupId: groupId }, requestOptions);
-            if (owner) {
-                opt.owner = owner;
-            }
-            return shareItemWithGroup(opt);
-        }));
+    function createProject(partialProject, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var project, _a, mapper, model, newProject;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        project = __assign(__assign({}, DEFAULT_PROJECT), partialProject);
+                        // Create a slug from the title if one is not passed in
+                        if (!project.slug) {
+                            project.slug = constructSlug(project.name, project.orgUrlKey);
+                        }
+                        // Ensure slug is  unique
+                        _a = project;
+                        return [4 /*yield*/, getUniqueSlug(project.slug, requestOptions)];
+                    case 1:
+                        // Ensure slug is  unique
+                        _a.slug = _b.sent();
+                        // add slug to keywords
+                        project.typeKeywords = setSlugKeyword(project.typeKeywords, project.slug);
+                        mapper = new PropertyMapper(getProjectPropertyMap());
+                        model = mapper.objectToModel(project, cloneObject$1(DEFAULT_PROJECT_MODEL));
+                        return [4 /*yield*/, createModel(model, requestOptions)];
+                    case 2:
+                        // create the item
+                        model = _b.sent();
+                        newProject = mapper.modelToObject(model, {});
+                        // and return it
+                        return [2 /*return*/, newProject];
+                }
+            });
+        });
     }
-
     /**
-     * Given a model, determine if it is protected, and unprotect it if it is.
-     * Otherwise, just resolve with the same result.
-     * @param {Object} model Model Object
-     * @param {IRequestOptions} requestOptions
+     * Update a Hub Project
+     * @param project
+     * @param requestOptions
      */
-    function unprotectModel(model, requestOptions) {
-        if (model.item.protected) {
-            var opts = Object.assign({ id: model.item.id }, requestOptions);
-            return unprotectItem(opts);
+    function updateProject(project, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, model, mapper, modelToUpdate, updatedModel, updatedProject;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // verify that the slug is unique
+                        // TODO: if the slug has not changed, we don't want to do this because
+                        // the existing item will cause this to increment
+                        _a = project;
+                        return [4 /*yield*/, getUniqueSlug(project.slug, requestOptions)];
+                    case 1:
+                        // verify that the slug is unique
+                        // TODO: if the slug has not changed, we don't want to do this because
+                        // the existing item will cause this to increment
+                        _a.slug = _b.sent();
+                        return [4 /*yield*/, getModel(project.id, requestOptions)];
+                    case 2:
+                        model = _b.sent();
+                        mapper = new PropertyMapper(getProjectPropertyMap());
+                        modelToUpdate = mapper.objectToModel(project, model);
+                        return [4 /*yield*/, updateModel(modelToUpdate, requestOptions)];
+                    case 3:
+                        updatedModel = _b.sent();
+                        updatedProject = mapper.modelToObject(updatedModel, project);
+                        // the casting is needed because modelToObject returns a `Partial<T>`
+                        // where as this function returns a `T`
+                        return [2 /*return*/, updatedProject];
+                }
+            });
+        });
+    }
+    /**
+     * Get a Hub Project by id or slug
+     * @param identifier item id or slug
+     * @param requestOptions
+     */
+    function getProject(identifier, requestOptions) {
+        var getPrms;
+        if (isGuid(identifier)) {
+            // get item by id
+            getPrms = getModel(identifier, requestOptions);
         }
         else {
-            // act as though we did it
-            return Promise.resolve({ success: true });
-        }
+            // search for item using filter=typekeywords:slug|identifier
+            getPrms = getModelBySlug(identifier, requestOptions);
+        }
+        return getPrms.then(function (model) {
+            // transform the model into a HubProject
+            var mapper = new PropertyMapper(getProjectPropertyMap());
+            var project = mapper.modelToObject(model, {});
+            return project;
+        });
     }
-
     /**
-     * Unshare an item from a set of groups
-     * @param {String} itemId Item Id to unshare from groups
-     * @param {Array} groups Array of group id's from which the item will be unshared
-     * @param {String} owner optional Owner username to determine which endpoint to hit
-     * @param {IRequestOptions} requestOptions
+     * Remove a Hub Project
+     * @param id
+     * @param requestOptions
      */
-    function unshareItemFromGroups(itemId, groups, requestOptions, owner) {
-        return Promise.all(groups.map(function (groupId) {
-            var opt = Object.assign({}, { id: itemId, groupId: groupId }, requestOptions);
-            if (owner) {
-                opt.owner = owner;
-            }
-            return unshareItemWithGroup(opt);
-        }));
+    function destroyProject(id, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ro;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ro = __assign(__assign({}, requestOptions), { id: id });
+                        return [4 /*yield*/, removeItem(ro)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
     }
+    // WIP: Need to resolve how best to execute this
+    // i.e. delegate to searchContent or just do an item search
+    // and convert to IHubProject objects.
+    //
+    // export async function searchProjects(
+    //   filter: Filter<"content">,
+    //   opts: IHubSearchOptions
+    // ): Promise<ISearchResponse<IHubProject>> {
+    //   return _searchContent(filter, opts).then((results) => {
+    //   })
+    // }
 
     /**
-     * Check if a site/page exists with a specific name
+     * Centralized functions used to manage IHubProject instances
+     *
+     * This class is a convenience wrapper over util functions which
+     * are also directly accessible for use in scenarios where
+     * classes are inconvenient.
      */
-    function doesItemExistWithTitle(itemTitle, options, authMgr) {
-        // if options have multiple properties, put them into one string separated with 'AND'
-        var optionsQuery = Object.keys(options)
-            .map(function (key) {
-            return key + ":\"" + options[key] + "\"";
-        })
-            .join(" AND ");
-        var opts = {
-            q: "title:\"" + itemTitle + "\" AND " + optionsQuery,
-            authentication: authMgr
+    var HubProjectManager = /** @class */ (function () {
+        /**
+         * Private so we can employ a factory function should we need
+         * async work during creation
+         * @param contextOrManager
+         */
+        function HubProjectManager(contextOrManager) {
+            if (contextOrManager instanceof ArcGISContextManager) {
+                this._contextManager = contextOrManager;
+            }
+            else {
+                this._context = contextOrManager;
+            }
+        }
+        /**
+         * Factory function to construct a new HubProjectManager instance.
+         *
+         * Note: Used so that we could do async actions in the ctor.
+         * @param contextOrManager
+         * @returns
+         */
+        HubProjectManager.init = function (contextOrManager) {
+            return new HubProjectManager(contextOrManager);
         };
-        return searchItems(opts)
-            .then(function (searchResponse) { return searchResponse.results.length > 0; })
-            .catch(function (e) {
-            throw Error("Error in doesItemExistWithTitle " + e);
+        Object.defineProperty(HubProjectManager.prototype, "context", {
+            /**
+             * Getter to abstract how we store the context
+             */
+            get: function () {
+                if (this._contextManager) {
+                    return this._contextManager.context;
+                }
+                else {
+                    return this._context;
+                }
+            },
+            enumerable: false,
+            configurable: true
         });
-    }
+        /**
+         * Create and store new project.
+         *
+         * Projects are stored as Items in the Sharing API
+         * @param project
+         * @param requestOptions
+         * @returns
+         */
+        HubProjectManager.prototype.create = function (project, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (requestOptions || this.context.isAuthenticated) {
+                        // ammend in the orgUrlKey
+                        if (!project.orgUrlKey) {
+                            project.orgUrlKey = this.context.portal.urlKey;
+                        }
+                        return [2 /*return*/, createProject(project, requestOptions || this.context.userRequestOptions)];
+                    }
+                    else {
+                        throw new HubError("Create Project", "Creating Hub Projects requires authentication.");
+                    }
+                });
+            });
+        };
+        /**
+         * Update a project
+         * @param project
+         * @param requestOptions
+         * @returns
+         */
+        HubProjectManager.prototype.update = function (project, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (requestOptions || this.context.isAuthenticated) {
+                        return [2 /*return*/, updateProject(project, requestOptions || this.context.userRequestOptions)];
+                    }
+                    else {
+                        throw new HubError("Update Project", "Updating Hub Projects requires authentication.");
+                    }
+                });
+            });
+        };
+        /**
+         * Destroy a project.
+         * This permanently removes the backing Item
+         * @param id
+         * @param requestOptions
+         * @returns
+         */
+        HubProjectManager.prototype.destroy = function (id, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (requestOptions || this.context.isAuthenticated) {
+                        return [2 /*return*/, destroyProject(id, requestOptions || this.context.userRequestOptions)];
+                    }
+                    else {
+                        throw new HubError("Destroy Project", "Destroying Hub Projects requires authentication.");
+                    }
+                });
+            });
+        };
+        /**
+         * Fetch a Project via id or it's slug
+         *
+         * This function does not require a user to be
+         * authenticated, but it does require an `IRequestOptions`
+         * which contains the portal instance to communicate with
+         * @param identifier
+         * @param requestOptions
+         * @returns
+         */
+        HubProjectManager.prototype.fetch = function (identifier, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (requestOptions || this.context.requestOptions) {
+                        return [2 /*return*/, getProject(identifier, requestOptions || this.context.requestOptions)];
+                    }
+                    else {
+                        throw new HubError("Get Project", "Can not retrieve context.requestOptions from Context Manager. HubProjectManager is configured incorrectly.");
+                    }
+                });
+            });
+        };
+        return HubProjectManager;
+    }());
 
     /**
-     * Given a title, construct a site/page title that is unique
-     * if that title exists, this fn will add a number on the end, and increment until
-     * an available title is found
-     * @param {string} title site/page title to ensure if unique
-     * @param {object} options an object that can be passed in to the q, eg. typekeywords, type
-     * @param {object} authMgr auth info tells the function what url to use for the "root" of the API,
-     * if missing, it will search against PROD
-     * @param {number} step Number to increment. Defaults to 0
+     * remote server error
      */
-    function getUniqueItemTitle(title, options, authMgr, step) {
-        if (step === void 0) { step = 0; }
-        var combinedName = title;
-        if (step) {
-            combinedName = title + " " + step;
+    var RemoteServerError = /** @class */ (function (_super) {
+        __extends(RemoteServerError, _super);
+        function RemoteServerError(message, url, status) {
+            var _this = _super.call(this, message) || this;
+            _this.status = status;
+            _this.url = url;
+            return _this;
         }
-        return doesItemExistWithTitle(combinedName, options, authMgr)
-            .then(function (result) {
-            if (result) {
-                step++;
-                return getUniqueItemTitle(title, options, authMgr, step);
+        return RemoteServerError;
+    }(Error));
+    /**
+     * ```js
+     * import { hubApiRequest } from "@esri/hub-common";
+     * //
+     * hubApiRequest(
+     *   "/datasets",
+     *   requestOptions
+     * })
+     *   .then(response);
+     * ```
+     * make a request to the Hub API
+     * @param route API route
+     * @param requestOptions request options
+     */
+    function hubApiRequest(route, requestOptions) {
+        // merge in default request options
+        var options = __assign({ 
+            // why do we default to GET w/ our API?
+            httpMethod: "GET" }, requestOptions);
+        // use fetch override if any
+        var _fetch = options.fetch || fetch;
+        // merge in default headers
+        var headers = __assign({ "Content-Type": "application/json" }, options.headers);
+        // build query params/body based on requestOptions.params
+        var query;
+        var body;
+        if (options.httpMethod === "GET") {
+            // pass params in query string
+            query = options.params;
+        }
+        else {
+            // pass params in request body
+            body = JSON.stringify(options.params);
+        }
+        // build Hub API URL
+        var url = buildUrl({
+            host: getHubApiUrl(options),
+            path: ("/api/v3/" + route).replace(/\/\//g, "/"),
+            query: query,
+        });
+        return _fetch(url, {
+            method: options.httpMethod,
+            headers: headers,
+            body: body,
+        }).then(function (resp) {
+            if (resp.ok) {
+                return resp.json();
             }
             else {
-                return combinedName;
-            }
-        })
-            .catch(function (e) {
-            throw Error("Error in getUniqueItemTitle " + e);
-        });
-    }
-
-    var MAX_NUM = 100;
-    /**
-     * Fetches all the pages in a search request
-     * @param {SearchFunction} searchFunc
-     * @param {ISearchOptions} opts
-     * @param {number} limit
-     * @param {batchSize} number of concurrent requests at a time
-     * @returns {Promise<SearchableType[]>}
-     */
-    function fetchAllPages(searchFunc, opts, limit, batchSize) {
-        if (limit === void 0) { limit = -1; }
-        var pageSize = opts.num || MAX_NUM;
-        var firstStart = opts.start || 1;
-        // If a limit is provided, we don't have to use the first request to get the
-        // total count before sending things off to batch(). So instead we fake the first
-        // response just to set things up.
-        var promise = limit === -1
-            ? searchFunc(__assign(__assign({}, opts), { num: pageSize, start: firstStart }))
-            : Promise.resolve({
-                nextStart: firstStart,
-                total: limit,
-                results: [],
-                num: pageSize
-            });
-        return promise
-            .then(function (firstResponse) {
-            // no more requests needed, return the first response
-            if (firstResponse.nextStart === -1)
-                return [firstResponse];
-            // generate batch requests for the remaining pages to fetch
-            var starts = [];
-            for (var i = firstResponse.nextStart; i <= firstResponse.total; i += pageSize) {
-                starts.push(i);
+                throw new RemoteServerError(resp.statusText, url, resp.status);
             }
-            var batchSearchFunc = function (start) {
-                return searchFunc(__assign(__assign({}, opts), { start: start, num: pageSize }));
-            };
-            return batch(starts, batchSearchFunc, batchSize).then(function (responses) { return __spreadArrays([
-                firstResponse
-            ], responses); });
-        })
-            .then(function (responses) {
-            // merge all the search results into a single array
-            var results = responses.reduce(function (acc, response) { return __spreadArrays(acc, response.results); }, []);
-            // discard results beyond the limit if applicable
-            var clipLimit = limit === -1 ? results.length : limit;
-            return results.slice(0, clipLimit);
         });
     }
 
@@ -8793,7 +10302,7 @@
      * Construct a the full url to a group thumbnail
      *
      * - If the group has a thumbnail, construct the full url
-     * - If the group is not public, append on the token
+     * - If the group is not public, append on the token (if passed in)
      * @param portalUrl
      * @param group
      * @param token
@@ -9524,12 +11033,11 @@
             return __generator(this, function (_b) {
                 expanded = expandContentFilter(filter);
                 api = expandApi(options.api || "arcgis");
-                // map over the apis, depending on the type we issue the queries
-                // const searchPromises = apis.map((api) => {
                 // Portal Search
                 if (api.type === "arcgis") {
                     so = serializeContentFilterForPortal(expanded);
-                    // pass auth forward
+                    // if we have auth, pass it forward
+                    // otherwise set the portal property
                     if (options.authentication) {
                         so.authentication = options.authentication;
                     }
@@ -9542,7 +11050,6 @@
                         so.countSize = 200;
                     }
                     // copy over various options
-                    // TODO: Dry this up - typscript makes this... inconvenient
                     if (options.num) {
                         so.num = options.num;
                     }
@@ -9569,8 +11076,6 @@
                         },
                     });
                 }
-                // });
-                // return for results
                 return [2 /*return*/, searchPromise];
             });
         });
@@ -9584,14 +11089,29 @@
      * @returns
      */
     function searchPortal(searchOptions) {
+        var _a;
+        var portalUrl = ((_a = searchOptions.authentication) === null || _a === void 0 ? void 0 : _a.portal) || searchOptions.portal;
+        var token;
+        if (searchOptions.authentication) {
+            var us = searchOptions.authentication;
+            token = us.token;
+        }
+        var thumbnailify = function (content) {
+            content.thumbnailUrl = getItemThumbnailUrl(content, portalUrl, token);
+            return content;
+        };
         return searchItems(searchOptions).then(function (resp) {
             var hasNext = resp.nextStart > -1;
+            // convert items to IHubContent's
             var content = resp.results.map(itemToContent);
+            // if we have a site, add those urls
             if (searchOptions.site) {
                 content = content.map(function (entry) {
                     return setContentSiteUrls(entry, searchOptions.site);
                 });
             }
+            // add thumbnailUrl
+            content = content.map(thumbnailify);
             // convert aggregations into facets
             var facets = convertPortalResponseToFacets(resp);
             return {
@@ -9613,10 +11133,9 @@
      * @returns
      */
     function _searchGroups(filter, options) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             var expanded, api, so;
-            return __generator(this, function (_b) {
+            return __generator(this, function (_a) {
                 expanded = expandGroupFilter(filter);
                 api = expandApi(options.api || "arcgis");
                 if (api.type === "arcgis") {
@@ -9629,7 +11148,6 @@
                     else {
                         so.portal = api.url + "/sharing/rest";
                     }
-                    // TODO: Dry this up - typscript makes this... inconvenient
                     if (options.num) {
                         so.num = options.num;
                     }
@@ -9639,10 +11157,6 @@
                     if (options.sortOrder) {
                         so.sortOrder = options.sortOrder;
                     }
-                    api.url + "/sharing/rest";
-                    if ((_a = so.authentication) === null || _a === void 0 ? void 0 : _a.portal) {
-                        so.authentication.portal;
-                    }
                     if (options.site) {
                         so.site = cloneObject$1(options.site);
                     }
@@ -9665,8 +11179,7 @@
             group.siteTeamUrl = searchOptions.site.item.url + "/teams/" + group.id + "/about";
             return group;
         };
-        var portalUrl = ((_a = searchOptions.authentication) === null || _a === void 0 ? void 0 : _a.portal) ||
-            "https://www.arcgis.com/sharing/rest";
+        var portalUrl = ((_a = searchOptions.authentication) === null || _a === void 0 ? void 0 : _a.portal) || searchOptions.portal;
         var token;
         if (searchOptions.authentication) {
             var us = searchOptions.authentication;
@@ -10330,262 +11843,90 @@
         var clone = cloneObject$1(model);
         var oldDcatUS11Config = clone.data.values.dcatConfig;
         clone.data.feeds = {};
-        if (oldDcatUS11Config) {
-            clone.data.feeds.dcatUS11 = _migrateToV3Values(oldDcatUS11Config);
-        }
-        clone.item.properties.schemaVersion = 1.5;
-        return clone;
-    }
-    var indexValueToV3Value = {
-        // Defaults
-        "{{default.name}}": "{{name}}",
-        "{{default.description}}": "{{description}}",
-        "{{item.tags}}": "{{tags}}",
-        "{{item.created:toISO}}": "{{created:toISO}}",
-        "{{item.modified:toISO}}": "{{modified:toISO}}",
-        "{{default.source.source}}": "{{source}}",
-        "{{item.owner}}": "{{owner}}",
-        "{{org.portalProperties.links.contactUs.url}}": "{{orgContactEmail}}",
-        // Custom Values
-        "{{org.name}}": "{{orgName}}",
-        "{{item.categories}}": "{{categories}}",
-        "{{item.licenseInfo}}": "{{licenseInfo}}",
-        "{{item.modified}}": "{{modified}}",
-        "{{enrichments.categories}}": "{{categories}}",
-        "{{default.id}}": "{{id}}",
-        "{{item.licenseInfo || No License}}": "{{licenseInfo || No License}}",
-        "{{org.portalProperties.links.contactUs.url || mailto:data@tempe.gov}}": "{{orgContactEmail || mailto:data@tempe.gov}}",
-        "{{default.description || No Description}}": "{{description || No Description}}",
-        "{{item.id}}": "{{id}}",
-    };
-    function _migrateToV3Values(originalConfig) {
-        var migratedConfigString = JSON.stringify(originalConfig);
-        var supportedIndexValues = Object.keys(indexValueToV3Value);
-        supportedIndexValues.forEach(function (indexValue) {
-            // Replace all occurrences of indexValue with the corresponding v3Value
-            var v3Value = indexValueToV3Value[indexValue];
-            migratedConfigString = migratedConfigString.split(indexValue).join(v3Value);
-        });
-        return JSON.parse(migratedConfigString);
-    }
-
-    /**
-     * Upgrades the schema upgrades
-     * @param model IModel
-     */
-    function upgradeSiteSchema(model) {
-        if (getProp(model, "item.properties.schemaVersion") === SITE_SCHEMA_VERSION) {
-            return model;
-        }
-        else {
-            // apply upgrade functions in order...
-            model = _applySiteSchema(model);
-            model = _enforceLowercaseDomains(model);
-            model = _ensureCatalog(model);
-            model = _purgeNonGuidsFromCatalog(model);
-            model = _ensureTelemetry(model);
-            model = _migrateFeedConfig(model);
-            // WARNING - If you are writing a site schema migration,
-            // you probably need to apply it to site drafts as well!
-            // See https://github.com/Esri/hub.js/issues/498 for more details.
-            return model;
-        }
-    }
-
-    /**
-     * Returns site model given various kinds of identifier
-     *
-     * @param identifier - a site item ID, site hostname, enterprise site slug, or full site URL
-     * @param hubRequestOptions
-     */
-    function fetchSite(identifier, hubRequestOptions) {
-        var prms;
-        if (isGuid(identifier)) {
-            prms = getSiteById(identifier, hubRequestOptions);
-        }
-        else {
-            var hostnameOrSlug = identifier;
-            // get down the the hostname
-            hostnameOrSlug = stripProtocol(hostnameOrSlug);
-            hostnameOrSlug = hostnameOrSlug.split("/")[0];
-            prms = lookupDomain(hostnameOrSlug, hubRequestOptions).then(function (_a) {
-                var siteId = _a.siteId;
-                return getSiteById(siteId, hubRequestOptions);
-            });
-        }
-        return prms;
-    }
-
-    /**
-     * Locales supported by the hub
-     */
-    var HUB_LOCALES = [
-        "ar",
-        "bs",
-        "ca",
-        "cs",
-        "da",
-        "de",
-        "en",
-        "es",
-        "et",
-        "el",
-        "fi",
-        "fr",
-        "hr",
-        "he",
-        "hu",
-        "it",
-        "id",
-        "ja",
-        "ko",
-        "lt",
-        "lv",
-        "nb",
-        "nl",
-        "pl",
-        "pt",
-        "pt-br",
-        "pt-pt",
-        "ro",
-        "ru",
-        "sl",
-        "sr",
-        "sv",
-        "th",
-        "tr",
-        "uk",
-        "vi",
-        "zh",
-        "zh-cn",
-        "zh-tw",
-        "zh-hk"
-    ];
-
-    /**
-     * Convert a requested locale into a locale we support.
-     * i.e. en-ca => en
-     * If the requested locale is not available, en will be returned
-     * @param {string} requestedLocale Locale we want
-     */
-    function convertToWellKnownLocale(requestedLocale) {
-        if (requestedLocale === void 0) { requestedLocale = "en"; }
-        var wellKnownKey = "en";
-        // ensure downcase
-        requestedLocale = requestedLocale.toLowerCase();
-        // see if it's in the hub translations as-is
-        if (HUB_LOCALES.indexOf(requestedLocale) > -1) {
-            wellKnownKey = requestedLocale;
-        }
-        else {
-            // if we split the requested locale, see if we have the root in the list
-            var parts = requestedLocale.split("-");
-            if (parts.length > 1 && HUB_LOCALES.indexOf(parts[0]) > -1) {
-                wellKnownKey = parts[0];
-            }
-        }
-        return wellKnownKey;
-    }
-
-    /**
-     * Fetch the Hub translation file for a given locale
-     * These are all public urls and should never require auth/tokens etc
-     * @param {String} locale Locale code - i.e. `es`
-     * @param {Object} portal Portal Self
-     */
-    function fetchHubTranslation(locale, portal, mode) {
-        if (mode === void 0) { mode = "cors"; }
-        var assetBase = getHubLocaleAssetUrl(portal);
-        var url = (assetBase + "/locales/" + locale + ".json").toLocaleLowerCase();
-        // to support web-tier auth, we must always send same-origin credentials
-        var options = {
-            method: "GET",
-            credentials: "same-origin",
-            mode: mode
-        };
-        return fetch(url, options)
-            .then(function (response) { return response.json(); })
-            .catch(function (err) {
-            throw Error("Attempt to fetch locale " + locale + " from " + url + " failed: " + JSON.stringify(err));
+        if (oldDcatUS11Config) {
+            clone.data.feeds.dcatUS11 = _migrateToV3Values(oldDcatUS11Config);
+        }
+        clone.item.properties.schemaVersion = 1.5;
+        return clone;
+    }
+    var indexValueToV3Value = {
+        // Defaults
+        "{{default.name}}": "{{name}}",
+        "{{default.description}}": "{{description}}",
+        "{{item.tags}}": "{{tags}}",
+        "{{item.created:toISO}}": "{{created:toISO}}",
+        "{{item.modified:toISO}}": "{{modified:toISO}}",
+        "{{default.source.source}}": "{{source}}",
+        "{{item.owner}}": "{{owner}}",
+        "{{org.portalProperties.links.contactUs.url}}": "{{orgContactEmail}}",
+        // Custom Values
+        "{{org.name}}": "{{orgName}}",
+        "{{item.categories}}": "{{categories}}",
+        "{{item.licenseInfo}}": "{{licenseInfo}}",
+        "{{item.modified}}": "{{modified}}",
+        "{{enrichments.categories}}": "{{categories}}",
+        "{{default.id}}": "{{id}}",
+        "{{item.licenseInfo || No License}}": "{{licenseInfo || No License}}",
+        "{{org.portalProperties.links.contactUs.url || mailto:data@tempe.gov}}": "{{orgContactEmail || mailto:data@tempe.gov}}",
+        "{{default.description || No Description}}": "{{description || No Description}}",
+        "{{item.id}}": "{{id}}",
+    };
+    function _migrateToV3Values(originalConfig) {
+        var migratedConfigString = JSON.stringify(originalConfig);
+        var supportedIndexValues = Object.keys(indexValueToV3Value);
+        supportedIndexValues.forEach(function (indexValue) {
+            // Replace all occurrences of indexValue with the corresponding v3Value
+            var v3Value = indexValueToV3Value[indexValue];
+            migratedConfigString = migratedConfigString.split(indexValue).join(v3Value);
         });
+        return JSON.parse(migratedConfigString);
     }
 
     /**
-     * Return the culture from the Hub Request Options
-     * In priority order: user.culture, portal.culture, en-us
-     * @param {IHubRequestOptions} hubRequestOptions
+     * Upgrades the schema upgrades
+     * @param model IModel
      */
-    function getCulture(hubRequestOptions) {
-        return (getProp(hubRequestOptions, "portalSelf.user.culture") ||
-            getProp(hubRequestOptions, "portalSelf.culture") ||
-            "en-us");
+    function upgradeSiteSchema(model) {
+        if (getProp(model, "item.properties.schemaVersion") === SITE_SCHEMA_VERSION) {
+            return model;
+        }
+        else {
+            // apply upgrade functions in order...
+            model = _applySiteSchema(model);
+            model = _enforceLowercaseDomains(model);
+            model = _ensureCatalog(model);
+            model = _purgeNonGuidsFromCatalog(model);
+            model = _ensureTelemetry(model);
+            model = _migrateFeedConfig(model);
+            // WARNING - If you are writing a site schema migration,
+            // you probably need to apply it to site drafts as well!
+            // See https://github.com/Esri/hub.js/issues/498 for more details.
+            return model;
+        }
     }
 
     /**
-     * remote server error
-     */
-    var RemoteServerError = /** @class */ (function (_super) {
-        __extends(RemoteServerError, _super);
-        function RemoteServerError(message, url, status) {
-            var _this = _super.call(this, message) || this;
-            _this.status = status;
-            _this.url = url;
-            return _this;
-        }
-        return RemoteServerError;
-    }(Error));
-    /**
-     * ```js
-     * import { hubApiRequest } from "@esri/hub-common";
-     * //
-     * hubApiRequest(
-     *   "/datasets",
-     *   requestOptions
-     * })
-     *   .then(response);
-     * ```
-     * make a request to the Hub API
-     * @param route API route
-     * @param requestOptions request options
+     * Returns site model given various kinds of identifier
+     *
+     * @param identifier - a site item ID, site hostname, enterprise site slug, or full site URL
+     * @param hubRequestOptions
      */
-    function hubApiRequest(route, requestOptions) {
-        // merge in default request options
-        var options = __assign({ 
-            // why do we default to GET w/ our API?
-            httpMethod: "GET" }, requestOptions);
-        // use fetch override if any
-        var _fetch = options.fetch || fetch;
-        // merge in default headers
-        var headers = __assign({ "Content-Type": "application/json" }, options.headers);
-        // build query params/body based on requestOptions.params
-        var query;
-        var body;
-        if (options.httpMethod === "GET") {
-            // pass params in query string
-            query = options.params;
+    function fetchSite(identifier, hubRequestOptions) {
+        var prms;
+        if (isGuid(identifier)) {
+            prms = getSiteById(identifier, hubRequestOptions);
         }
         else {
-            // pass params in request body
-            body = JSON.stringify(options.params);
+            var hostnameOrSlug = identifier;
+            // get down the the hostname
+            hostnameOrSlug = stripProtocol(hostnameOrSlug);
+            hostnameOrSlug = hostnameOrSlug.split("/")[0];
+            prms = lookupDomain(hostnameOrSlug, hubRequestOptions).then(function (_a) {
+                var siteId = _a.siteId;
+                return getSiteById(siteId, hubRequestOptions);
+            });
         }
-        // build Hub API URL
-        var url = buildUrl({
-            host: getHubApiUrl(options),
-            path: ("/api/v3/" + route).replace(/\/\//g, "/"),
-            query: query,
-        });
-        return _fetch(url, {
-            method: options.httpMethod,
-            headers: headers,
-            body: body,
-        }).then(function (resp) {
-            if (resp.ok) {
-                return resp.json();
-            }
-            else {
-                throw new RemoteServerError(resp.statusText, url, resp.status);
-            }
-        });
+        return prms;
     }
 
     /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
@@ -10603,641 +11944,210 @@
             var featureService = _a.relatedItems[0];
             var model;
             if (featureService) {
-                model = { item: featureService };
-            }
-            return model;
-        });
-    };
-
-    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
-     * Apache-2.0 */
-    /**
-     * Fetches a Survey's source Feature Service from a given
-     * Fieldworker View ID
-     * @param {string} fieldworkerId The Fieldworker View ID
-     * @param {IRequestOptions} requestOptions The request options
-     * @returns {Promise<IModel>}
-     */
-    var getSourceFeatureServiceModelFromFieldworker = function (fieldworkerId, requestOptions) {
-        return getRelatedItems(__assign({ id: fieldworkerId, relationshipType: "Service2Data", direction: "forward" }, requestOptions)).then(function (_a) {
-            var featureService = _a.relatedItems[0];
-            var model;
-            if (featureService) {
-                model = { item: featureService };
-            }
-            return model;
-        });
-    };
-
-    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
-     * Apache-2.0 */
-    /**
-     * Fetches a Survey's Stakeholder View for a given
-     * Form ID
-     * @param {string} formId A Form ID
-     * @param {IRequestOptions} requestOptions The request options
-     * @returns {Promise<IModel>}
-     */
-    var getStakeholderModel = function (formId, requestOptions) {
-        return getRelatedItems(__assign({ id: formId, relationshipType: "Survey2Data", direction: "forward" }, requestOptions)).then(function (_a) {
-            var stakeholderView = _a.relatedItems[0];
-            var model;
-            if (stakeholderView) {
-                model = { item: stakeholderView };
-            }
-            return model;
-        });
-    };
-
-    /**
-     * Determines if the provided Feature Service item is a
-     * Fieldworker View
-     * @param {IItem} featureServiceItem
-     * @returns {boolean}
-     */
-    function isFieldworkerView(featureServiceItem) {
-        var hasTypekeyword = function (typeKeyword) {
-            return featureServiceItem.typeKeywords.indexOf(typeKeyword) > -1;
-        };
-        // Survey123 only recently added the "FieldworkerView" typekeyword
-        var isFieldworker = hasTypekeyword("FieldworkerView");
-        // we should support previously created fieldworkers too
-        if (!isFieldworker) {
-            var hasExpectedTypeKeywords = [
-                "Survey123",
-                "Feature Service",
-                "View Service",
-            ].every(hasTypekeyword);
-            isFieldworker =
-                hasExpectedTypeKeywords && !hasTypekeyword("StakeholderView");
-        }
-        return isFieldworker;
-    }
-
-    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
-     * Apache-2.0 */
-    /**
-     * Builds a dictionary of Survey items for the given Form model
-     * @param {string} formId The Form ID of the survey
-     * @param {IRequestOptions} requestOptions The request options
-     * @returns {Promise<IGetSurveyModelsResponse>}
-     */
-    var getSurveyModels = function (formItemOrId, requestOptions) {
-        var fieldworker;
-        var stakeholder;
-        var getForm = function () {
-            return typeof formItemOrId === "string"
-                ? getItem(formItemOrId, requestOptions)
-                : Promise.resolve(formItemOrId);
-        };
-        return getForm().then(function (form) {
-            var promises = [
-                // the primary input will be the fieldworker (if it exists), otherwise
-                // the source feature service.
-                getInputFeatureServiceModel(form.id, requestOptions),
-                getStakeholderModel(form.id, requestOptions),
-            ];
-            return Promise.all(promises)
-                .then(function (_a) {
-                var featureServiceOrFieldworkerModelResult = _a[0], stakeholderResult = _a[1];
-                stakeholder = stakeholderResult;
-                if (featureServiceOrFieldworkerModelResult &&
-                    isFieldworkerView(featureServiceOrFieldworkerModelResult.item)) {
-                    fieldworker = featureServiceOrFieldworkerModelResult;
-                    // if the primary input is the fieldworker, fetch
-                    // the source feature service
-                    return getSourceFeatureServiceModelFromFieldworker(fieldworker.item.id, requestOptions);
-                }
-                else {
-                    return featureServiceOrFieldworkerModelResult;
-                }
-            })
-                .then(function (featureService) {
-                return {
-                    form: { item: form },
-                    featureService: featureService,
-                    fieldworker: fieldworker,
-                    stakeholder: stakeholder,
-                };
-            });
+                model = { item: featureService };
+            }
+            return model;
         });
     };
 
+    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
     /**
-     * Hash of Hub API end points so updates
-     * are centralized
+     * Fetches a Survey's source Feature Service from a given
+     * Fieldworker View ID
+     * @param {string} fieldworkerId The Fieldworker View ID
+     * @param {IRequestOptions} requestOptions The request options
+     * @returns {Promise<IModel>}
      */
-    var hubApiEndpoints = {
-        domains: "/api/v3/domains",
-        search: "/api/v3/datasets",
-        discussions: "/api/discussions/v1",
+    var getSourceFeatureServiceModelFromFieldworker = function (fieldworkerId, requestOptions) {
+        return getRelatedItems(__assign({ id: fieldworkerId, relationshipType: "Service2Data", direction: "forward" }, requestOptions)).then(function (_a) {
+            var featureService = _a.relatedItems[0];
+            var model;
+            if (featureService) {
+                model = { item: featureService };
+            }
+            return model;
+        });
     };
+
+    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
     /**
-     * @internal
-     * Thin class just used to enable getters
-     *
-     * This class should not be used by anything other than
-     * the ArcGISContext class
+     * Fetches a Survey's Stakeholder View for a given
+     * Form ID
+     * @param {string} formId A Form ID
+     * @param {IRequestOptions} requestOptions The request options
+     * @returns {Promise<IModel>}
      */
-    var ArcGISContextState = /** @class */ (function () {
-        function ArcGISContextState(opts) {
-            this._portalUrl = "https://www.arcgis.com";
-            this.id = opts.id;
-            this._portalUrl = opts.portalUrl;
-            this._hubUrl = opts.hubUrl;
-            if (opts.authentication) {
-                this._authentication = opts.authentication;
-            }
-            if (opts.portalSelf) {
-                this._portalSelf = opts.portalSelf;
-            }
-            if (opts.currentUser) {
-                this._currentUser = opts.currentUser;
+    var getStakeholderModel = function (formId, requestOptions) {
+        return getRelatedItems(__assign({ id: formId, relationshipType: "Survey2Data", direction: "forward" }, requestOptions)).then(function (_a) {
+            var stakeholderView = _a.relatedItems[0];
+            var model;
+            if (stakeholderView) {
+                model = { item: stakeholderView };
             }
-        }
-        Object.defineProperty(ArcGISContextState.prototype, "session", {
-            /**
-             * Return the UserSession if authenticated
-             */
-            get: function () {
-                return this._authentication;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "isAuthenticated", {
-            /**
-             * Return boolean indicating if authenticatio is present
-             */
-            get: function () {
-                return !!this._authentication;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "userRequestOptions", {
-            /**
-             * Return `IUserRequestOptions`, which is used for REST-JS
-             * functions which require authentication information.
-             *
-             * If context is not authenticated, this function will throw
-             */
-            get: function () {
-                if (this.isAuthenticated) {
-                    return {
-                        authentication: this._authentication,
-                        portal: this.sharingApiUrl,
-                    };
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "requestOptions", {
-            /**
-             * Return `IRequestOptions`, which is used by REST-JS functions
-             * which *may* use authentication information if provided.
-             *
-             * If context is not authenticated, this function just returns
-             * the `portal` property, which informs REST-JS what Sharing API
-             * instance to use (i.e. AGO, Enterprise etc)
-             */
-            get: function () {
-                var ro = {
-                    portal: this.sharingApiUrl,
-                };
-                if (this.isAuthenticated) {
-                    ro = {
-                        authentication: this._authentication,
-                        portal: this.sharingApiUrl,
-                    };
-                }
-                return ro;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "hubRequestOptions", {
-            /**
-             * Return a `IHubRequestOptions` object
-             */
-            get: function () {
-                // We may add more logic around what is returned in some corner cases
-                return {
-                    authentication: this.session,
-                    isPortal: this.isPortal,
-                    portalSelf: this.portal,
-                    hubApiUrl: this.hubUrl,
-                };
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "portalUrl", {
-            // ==============================
-            // Getters / Computed Properties
-            // ==============================
-            /**
-             * Return the portal url.
-             *
-             * If authenticated @ ArcGIS Online, it will return
-             * the https://org.env.arcgis.com
-             *
-             * If authenticated @ ArcGIS Enterprise, it will return
-             * https://portalHostname, which includes the web adaptor
-             */
-            get: function () {
-                if (this.isAuthenticated) {
-                    if (this.isPortal) {
-                        return "https://" + this._portalSelf.portalHostname;
-                    }
-                    else {
-                        return "https://" + this._portalSelf.urlKey + "." + this._portalSelf.customBaseUrl;
-                    }
-                }
-                else {
-                    return this._portalUrl;
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "sharingApiUrl", {
-            /**
-             * Returns the url to the sharing api
-             * i.e. https://myorg.maps.arcgis.com/sharing/rest
-             */
-            get: function () {
-                return this.portalUrl + "/sharing/rest";
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "hubUrl", {
-            get: function () {
-                return this._hubUrl;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "isPortal", {
-            /**
-             * Returns boolean indicating if the backing system
-             * is ArcGIS Enterprise (formerly ArcGIS Portal) or not
-             */
-            get: function () {
-                return this._portalSelf
-                    ? this._portalSelf.isPortal
-                    : this._portalUrl.indexOf("arcgis.com") === -1;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "discussionsServiceUrl", {
-            // Hub APIs
-            // ----------
-            // Discussions
-            get: function () {
-                if (this._hubUrl) {
-                    return "" + this._hubUrl + hubApiEndpoints.discussions;
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "hubSearchServiceUrl", {
-            // Hub Search
-            get: function () {
-                if (this._hubUrl) {
-                    return "" + this._hubUrl + hubApiEndpoints.search;
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "domainServiceUrl", {
-            // Domain
-            get: function () {
-                if (this._hubUrl) {
-                    return "" + this._hubUrl + hubApiEndpoints.domains;
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "eventsConfig", {
-            // Events
-            // returns `{serviceId: '3ef..', publicViewId: 'bc3...'}
-            get: function () {
-                if (this._portalSelf) {
-                    return getProp(this._portalSelf, "portalProperties.hub.settings.events");
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "hubEnabled", {
-            /**
-             * Returns boolean indicating if the current user
-             * belongs to an organization that has licensed
-             * ArcGIS Hub
-             */
-            get: function () {
-                return getWithDefault$1(this._portalSelf, "portalProperties.hub.enabled", false);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "communityOrgId", {
-            /**
-             * Return Hub Community Org Id, if defined
-             */
-            get: function () {
-                if (this._portalSelf) {
-                    return getProp(this._portalSelf, "portalProperties.hub.settings.communityOrg.orgId");
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "communityOrgHostname", {
-            get: function () {
-                if (this._portalSelf) {
-                    return getProp(this._portalSelf, "portalProperties.hub.settings.communityOrg.portalHostname");
-                }
-            },
-            enumerable: false,
-            configurable: true
+            return model;
         });
-        Object.defineProperty(ArcGISContextState.prototype, "communityOrgUrl", {
-            get: function () {
-                if (this.communityOrgHostname) {
-                    return "https://" + this.communityOrgHostname;
+    };
+
+    /**
+     * Determines if the provided Feature Service item is a
+     * Fieldworker View
+     * @param {IItem} featureServiceItem
+     * @returns {boolean}
+     */
+    function isFieldworkerView(featureServiceItem) {
+        var hasTypekeyword = function (typeKeyword) {
+            return featureServiceItem.typeKeywords.indexOf(typeKeyword) > -1;
+        };
+        // Survey123 only recently added the "FieldworkerView" typekeyword
+        var isFieldworker = hasTypekeyword("FieldworkerView");
+        // we should support previously created fieldworkers too
+        if (!isFieldworker) {
+            var hasExpectedTypeKeywords = [
+                "Survey123",
+                "Feature Service",
+                "View Service",
+            ].every(hasTypekeyword);
+            isFieldworker =
+                hasExpectedTypeKeywords && !hasTypekeyword("StakeholderView");
+        }
+        return isFieldworker;
+    }
+
+    /* Copyright (c) 2020 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * Builds a dictionary of Survey items for the given Form model
+     * @param {string} formId The Form ID of the survey
+     * @param {IRequestOptions} requestOptions The request options
+     * @returns {Promise<IGetSurveyModelsResponse>}
+     */
+    var getSurveyModels = function (formItemOrId, requestOptions) {
+        var fieldworker;
+        var stakeholder;
+        var getForm = function () {
+            return typeof formItemOrId === "string"
+                ? getItem(formItemOrId, requestOptions)
+                : Promise.resolve(formItemOrId);
+        };
+        return getForm().then(function (form) {
+            var promises = [
+                // the primary input will be the fieldworker (if it exists), otherwise
+                // the source feature service.
+                getInputFeatureServiceModel(form.id, requestOptions),
+                getStakeholderModel(form.id, requestOptions),
+            ];
+            return Promise.all(promises)
+                .then(function (_a) {
+                var featureServiceOrFieldworkerModelResult = _a[0], stakeholderResult = _a[1];
+                stakeholder = stakeholderResult;
+                if (featureServiceOrFieldworkerModelResult &&
+                    isFieldworkerView(featureServiceOrFieldworkerModelResult.item)) {
+                    fieldworker = featureServiceOrFieldworkerModelResult;
+                    // if the primary input is the fieldworker, fetch
+                    // the source feature service
+                    return getSourceFeatureServiceModelFromFieldworker(fieldworker.item.id, requestOptions);
                 }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "helperServices", {
-            // Platform API service urls are all in helperServices
-            // and not consistent to expose as urls
-            get: function () {
-                if (this._portalSelf) {
-                    return this._portalSelf.helperServices;
+                else {
+                    return featureServiceOrFieldworkerModelResult;
                 }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "currentUser", {
-            get: function () {
-                return this._currentUser;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(ArcGISContextState.prototype, "portal", {
-            get: function () {
-                return this._portalSelf;
-            },
-            enumerable: false,
-            configurable: true
+            })
+                .then(function (featureService) {
+                return {
+                    form: { item: form },
+                    featureService: featureService,
+                    fieldworker: fieldworker,
+                    stakeholder: stakeholder,
+                };
+            });
         });
-        return ArcGISContextState;
-    }());
+    };
 
     /**
-     * Application Context Object
+     * Hub class can be used as an entry point to managing
+     * content, teams, sites, projects etc, in an organization's Hub.
+     *
+     * ```js
+     * import {Hub} from '@esri/hub-common';
+     * // create a Hub instance, authenticating as a specific user
+     * // working against arcgis online
+     * const myHub = await Hub.create({authOptions: {username: "casey", password: "jones"}});
+     *
+     * myHub.context.currentUser //=> {username: "casey", ...} as IUser
      *
-     * Abstraction that combines a `UserSession` with
-     * the `portal/self` and `user/self` responses to
-     * provide a central lookup of platform information.
+     * const projectStore = await myHub.getProjectStore();
      *
-     * This is a work-in-progress, and will likely expand over time.
+     * const pavingProject = await projectStore.create({name: "12th Street Paving"});
+     * pavingProject.summary = "This is the 2024 planned paving of 12th Street, between 8th and 11th Ave";
+     * await projectStore.update(pavingProject);
+     * ```
      *
-     * `ArcGISContext` is used in conjuction with the `arcgis-app-identity`
-     * component to orchestrate oAuth.
+     * This is a convenience class. Hub Stores can be created
+     * directly, or the underlying functions can be imported an used
+     * as need for scenarios where these class structures introduce
+     * unwanted complexity
      */
-    var ArcGISContext = /** @class */ (function () {
+    var Hub = /** @class */ (function () {
         /**
-         * Private constructor. Use `ArcGISContext.create(...)` to
-         * instantiate an instance
-         * @param opts
+         * Private so we can employ a factory function should we need
+         * async work during creation
+         * @param contextManager
          */
-        function ArcGISContext(opts) {
-            this._portalUrl = "https://www.arcgis.com";
-            this._debug = false;
-            // Having a unique id makes debugging easier
-            this.id = new Date().getTime();
-            if (opts.debug) {
-                this._debug = opts.debug;
-            }
-            this.log("ArcGISContext:ctor: Creating " + this.id);
-            if (opts.authentication) {
-                this._authentication = opts.authentication;
-                this._portalUrl = this._authentication.portal.replace("/sharing/rest", "");
-                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
-            }
-            else if (opts.portalUrl) {
-                this._portalUrl = opts.portalUrl;
-                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
-            }
-            else {
-                this._hubUrl = getHubApiFromPortalUrl(this._portalUrl);
-            }
-            if (opts.portal) {
-                this._portalSelf = cloneObject$1(opts.portal);
-            }
-            if (opts.currentUser) {
-                this._currentUser = cloneObject$1(opts.currentUser);
-            }
+        function Hub(contextManager) {
+            this._contextManager = contextManager;
         }
         /**
-         * Static async Factory
-         * @param opts
+         * Factory function to construct a new HubProjectStore instance.
+         *
+         * Note: Used so that we could do async actions in the ctor.
+         * @param contextManager
          * @returns
          */
-        ArcGISContext.create = function (opts) {
-            if (opts === void 0) { opts = {}; }
-            return __awaiter(this, void 0, void 0, function () {
-                var ctx;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            ctx = new ArcGISContext(opts);
-                            return [4 /*yield*/, ctx.initialize()];
-                        case 1:
-                            _a.sent();
-                            return [2 /*return*/, ctx];
-                    }
-                });
-            });
-        };
-        /**
-         * Set the Authentication (UserSession) for the context.
-         * This should be called when a user signs into a running
-         * application.
-         * @param auth
-         */
-        ArcGISContext.prototype.setAuthentication = function (auth) {
+        Hub.create = function (options) {
             return __awaiter(this, void 0, void 0, function () {
+                var opts, mgr;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            this._authentication = auth;
-                            this._portalUrl = auth.portal.replace("/sharing/rest", "");
-                            return [4 /*yield*/, this.initialize()];
+                            if (!options.contextManager) return [3 /*break*/, 1];
+                            return [2 /*return*/, new Hub(options.contextManager)];
                         case 1:
-                            _a.sent();
-                            return [2 /*return*/];
+                            opts = options.managerOptions || {};
+                            return [4 /*yield*/, ArcGISContextManager.create(opts)];
+                        case 2:
+                            mgr = _a.sent();
+                            return [2 /*return*/, new Hub(mgr)];
                     }
                 });
             });
         };
-        /**
-         * Clear the Authentication (UserSession). This should be
-         * called when a user signs out of an application, but
-         * the application continues running
-         */
-        ArcGISContext.prototype.clearAuthentication = function () {
-            // Reset the portalUrl from the org url to the base url
-            // for ArcGIS Enterprise, we just leave the _portalUrl as-is
-            if (!this._state.isPortal) {
-                this._portalUrl = getPortalBaseFromOrgUrl(this._portalUrl);
-            }
-            // Clear the auth, portalSelf and currentUser props
-            this._authentication = null;
-            this._portalSelf = null;
-            this._currentUser = null;
-            this._state = new ArcGISContextState({
-                id: this.id,
-                portalUrl: this._portalUrl,
-                hubUrl: this._hubUrl,
-            });
-        };
-        Object.defineProperty(ArcGISContext.prototype, "state", {
+        Object.defineProperty(Hub.prototype, "context", {
             /**
-             * Return a reference to the current state.
-             * When `.setAuthentication()` or `.clearAuthenentication()` are
-             * called, the state will be re-created. This is done so frameworks
-             * like React or Ember can detect changes.
+             * Getter to abstract the context manager
              */
             get: function () {
-                return this._state;
+                return this._contextManager.context;
             },
             enumerable: false,
             configurable: true
         });
-        /**
-         * @internal
-         * Log debugging messages to the console
-         * @param message
-         */
-        ArcGISContext.prototype.log = function (message) {
-            if (this._debug) {
-                // tslint:disable-next-line:no-console
-                console.info(message);
-            }
-        };
-        /**
-         * If we have a UserSession, fetch portal/self and
-         * store that along with current user
-         */
-        ArcGISContext.prototype.initialize = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var username, requests, _a, portal, user, ex_1, msg;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            if (!(this._authentication && (!this._portalSelf || !this._currentUser))) return [3 /*break*/, 4];
-                            this.log("ArcGISContext-" + this.id + ": Initializing");
-                            username = this._authentication.username;
-                            requests = [
-                                getSelf({ authentication: this._authentication }),
-                                getUser({ username: username, authentication: this._authentication }),
-                            ];
-                            _b.label = 1;
-                        case 1:
-                            _b.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, Promise.all(requests)];
-                        case 2:
-                            _a = _b.sent(), portal = _a[0], user = _a[1];
-                            this._portalSelf = portal;
-                            this._currentUser = user;
-                            return [3 /*break*/, 4];
-                        case 3:
-                            ex_1 = _b.sent();
-                            msg = "ArcGISContext could not fetch portal & user for \"" + this._authentication.username + "\" using " + this._authentication.portal + ".";
-                            // tslint:disable-next-line:no-console
-                            console.error(msg);
-                            throw ex_1;
-                        case 4:
-                            // update the state
-                            this._state = new ArcGISContextState(this.stateOpts);
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        Object.defineProperty(ArcGISContext.prototype, "stateOpts", {
+        Object.defineProperty(Hub.prototype, "projects", {
+            /**
+             * Create a Project Store connected to the current Hub
+             * @returns
+             */
             get: function () {
-                var stateOpts = {
-                    id: this.id,
-                    portalUrl: this._portalUrl,
-                    hubUrl: this._hubUrl,
-                };
-                if (this._authentication) {
-                    stateOpts.authentication = this._authentication;
-                }
-                if (this._portalSelf) {
-                    stateOpts.portalSelf = this._portalSelf;
+                if (!this._projectManager) {
+                    this._projectManager = HubProjectManager.init(this._contextManager);
                 }
-                if (this._currentUser) {
-                    stateOpts.currentUser = this._currentUser;
-                }
-                return stateOpts;
+                return this._projectManager;
             },
             enumerable: false,
             configurable: true
         });
-        return ArcGISContext;
+        return Hub;
     }());
-    /**
-     * Cross-walk from a portalUrl to the corresponding Hub.
-     *
-     * If the passed url is not recognized, then this will return `undefined`
-     * @param portalUrl
-     * @returns
-     */
-    function getHubApiFromPortalUrl(portalUrl) {
-        var result;
-        if (portalUrl.match(/(qaext|\.mapsqa)\.arcgis.com/)) {
-            result = "https://hubqa.arcgis.com";
-        }
-        else if (portalUrl.match(/(devext|\.mapsdevext)\.arcgis.com/)) {
-            result = "https://hubdev.arcgis.com";
-        }
-        else if (portalUrl.match(/(www|\.maps)\.arcgis.com/)) {
-            result = "https://hub.arcgis.com";
-        }
-        return result;
-    }
-    function getPortalBaseFromOrgUrl(orgUrl) {
-        var result;
-        if (orgUrl.match(/(qaext|\.mapsqa)\.arcgis.com/)) {
-            result = "https://qaext.arcgis.com";
-        }
-        else if (orgUrl.match(/(devext|\.mapsdevext)\.arcgis.com/)) {
-            result = "https://devext.arcgis.com";
-        }
-        else {
-            /* istanbul ignore else */
-            if (orgUrl.match(/(www|\.maps)\.arcgis.com/)) {
-                result = "https://www.arcgis.com";
-            }
-        }
-        return result;
-    }
 
     /* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
@@ -11498,10 +12408,52 @@
         return msg;
     }
 
+    /**
+     * Generic Hub Error with an Error stack as well
+     * as an optional serialized OperationStack.
+     *
+     * Also accepts a `rootCause` Error object
+     */
+    var HubError = /** @class */ (function (_super) {
+        __extends(HubError, _super);
+        /**
+         * Creates an instance of HubError.
+         * @param {string} operation
+         * @param {string} [message]
+         * @param {Error} [rootCause]
+         * @memberof HubError
+         */
+        function HubError(operation, message, rootCause) {
+            var _this = this;
+            message = message || "UNKNOWN_ERROR";
+            // if the rootCause has a .rootCause, use that so we don't deeply nest
+            rootCause = getWithDefault$1(rootCause, "rootCause", rootCause);
+            /* Skip coverage on super(...) as per:
+               https://github.com/Microsoft/TypeScript/issues/13029
+               https://github.com/SitePen/remap-istanbul/issues/106
+            */
+            /* istanbul ignore next */
+            _this = _super.call(this, operation, message, rootCause) || this;
+            _this.name = "HubError";
+            // if the original error has a stack use it, otherwise create a new
+            // stack. Note: a new Stack will make it look like the error origninated
+            // in the HubError constructor. This is only an issue in tests but
+            // it can be confusing to debug
+            _this.stack = getWithDefault$1(rootCause, "stack", new Error().stack);
+            return _this;
+        }
+        return HubError;
+    }(OperationError));
+
     exports.ArcGISContext = ArcGISContext;
+    exports.ArcGISContextManager = ArcGISContextManager;
     exports.GLOBAL_EXTENT = GLOBAL_EXTENT;
     exports.HUB_CDN_URLMAP = HUB_CDN_URLMAP;
     exports.HUB_LOCALES = HUB_LOCALES;
+    exports.HUB_PROJECT_ITEM_TYPE = HUB_PROJECT_ITEM_TYPE;
+    exports.Hub = Hub;
+    exports.HubError = HubError;
+    exports.HubProjectManager = HubProjectManager;
     exports.Logger = Logger;
     exports.OperationError = OperationError;
     exports.OperationStack = OperationStack;
@@ -11571,6 +12523,7 @@
     exports.cloneObject = cloneObject$1;
     exports.completeOAuth2 = completeOAuth2;
     exports.compose = compose;
+    exports.constructSlug = constructSlug;
     exports.convertContentDefinitionToFilter = convertContentDefinitionToFilter;
     exports.convertContentFilterToSearchOptions = convertContentFilterToSearchOptions;
     exports.convertPortalResponseToFacets = convertPortalResponseToFacets;
@@ -11579,7 +12532,10 @@
     exports.convertUrlsToAnchorTags = convertUrlsToAnchorTags;
     exports.createExtent = createExtent;
     exports.createId = createId;
+    exports.createModel = createModel;
     exports.createOperationPipeline = createOperationPipeline;
+    exports.createProject = createProject;
+    exports.dasherize = dasherize;
     exports.datasetToContent = datasetToContent;
     exports.datasetToItem = datasetToItem;
     exports.deepFind = deepFind;
@@ -11587,6 +12543,7 @@
     exports.deepSet = deepSet;
     exports.deepStringReplace = deepStringReplace;
     exports.deleteProp = deleteProp;
+    exports.destroyProject = destroyProject;
     exports.doesItemExistWithTitle = doesItemExistWithTitle;
     exports.domainExists = domainExists;
     exports.domainExistsPortal = domainExistsPortal;
@@ -11627,6 +12584,7 @@
     exports.getFamily = getFamily;
     exports.getGeographicOrgExtent = getGeographicOrgExtent;
     exports.getGroupThumbnailUrl = getGroupThumbnailUrl;
+    exports.getHubApiFromPortalUrl = getHubApiFromPortalUrl;
     exports.getHubApiUrl = getHubApiUrl;
     exports.getHubApiUrlFromPortal = getHubApiUrlFromPortal;
     exports.getHubLocaleAssetUrl = getHubLocaleAssetUrl;
@@ -11635,6 +12593,7 @@
     exports.getInputFeatureServiceModel = getInputFeatureServiceModel;
     exports.getItemApiUrl = getItemApiUrl;
     exports.getItemAssets = getItemAssets;
+    exports.getItemBySlug = getItemBySlug;
     exports.getItemDataUrl = getItemDataUrl;
     exports.getItemHomeUrl = getItemHomeUrl;
     exports.getItemHubId = getItemHubId;
@@ -11643,13 +12602,17 @@
     exports.getItemThumbnailUrl = getItemThumbnailUrl;
     exports.getLayerIdFromUrl = getLayerIdFromUrl;
     exports.getModel = getModel;
+    exports.getModelBySlug = getModelBySlug;
     exports.getModelFromOptions = getModelFromOptions;
     exports.getNextFunction = getNextFunction;
     exports.getOrgExtentAsBBox = getOrgExtentAsBBox;
     exports.getPortalApiUrl = getPortalApiUrl;
+    exports.getPortalBaseFromOrgUrl = getPortalBaseFromOrgUrl;
     exports.getPortalUrl = getPortalUrl;
+    exports.getProject = getProject;
     exports.getProp = getProp;
     exports.getProps = getProps;
+    exports.getProxyUrl = getProxyUrl;
     exports.getServiceTypeFromUrl = getServiceTypeFromUrl;
     exports.getSession = getSession;
     exports.getSiteById = getSiteById;
@@ -11664,6 +12627,7 @@
     exports.getUniqueDomainName = getUniqueDomainName;
     exports.getUniqueDomainNamePortal = getUniqueDomainNamePortal;
     exports.getUniqueItemTitle = getUniqueItemTitle;
+    exports.getUniqueSlug = getUniqueSlug;
     exports.getUserThumbnailUrl = getUserThumbnailUrl;
     exports.getWithDefault = getWithDefault$1;
     exports.hasBasePriv = hasBasePriv;
@@ -11729,6 +12693,7 @@
     exports.setContentSiteUrls = setContentSiteUrls;
     exports.setContentType = setContentType;
     exports.setProp = setProp;
+    exports.setSlugKeyword = setSlugKeyword;
     exports.shareItemToGroups = shareItemToGroups;
     exports.slugify = slugify;
     exports.stringToBlob = stringToBlob;
@@ -11738,6 +12703,8 @@
     exports.unprotectModel = unprotectModel;
     exports.unshareItemFromGroups = unshareItemFromGroups;
     exports.updateDomain = updateDomain;
+    exports.updateModel = updateModel;
+    exports.updateProject = updateProject;
     exports.upgradeProtocol = upgradeProtocol;
     exports.upgradeSiteSchema = upgradeSiteSchema;
     exports.uploadResourcesFromUrl = uploadResourcesFromUrl;