@esri/hub-common 9.43.3 → 9.45.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.43.2 - Thu Jun 23 2022 17:43:06 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.44.1 - Tue Jun 28 2022 15:39:40 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -5631,7 +5631,7 @@
              */
             get: function () {
                 if (this.isAuthenticated) {
-                    if (this.isPortal) {
+                    if (this.isPortal || !this._portalSelf.urlKey) {
                         return "https://" + this._portalSelf.portalHostname;
                     }
                     else {
@@ -13548,7 +13548,7 @@
      * @param join
      * @returns
      */
-    function mergeSearchOptions$1(so1, so2, join) {
+    function mergeSearchOptions$2(so1, so2, join) {
         // TODO: Remove with _searchContent
         Logger.warn("DEPRECATION: mergeSearchOptions will be removed. Work with IFilterGroups<\"group\"> and hubSearch() instead");
         var result = cloneObject$1(so1);
@@ -13569,7 +13569,7 @@
      * @param opts
      * @returns
      */
-    function serializeMatchOptions$1(key, opts) {
+    function serializeMatchOptions$2(key, opts) {
         var result = {
             q: "",
             filter: "",
@@ -13594,7 +13594,7 @@
             var groupFilterableFields = ["title", "typekeywords", "owner"];
             var filterableFields = __spreadArrays(userFilterableFields, itemFilterableFields, groupFilterableFields);
             if (filterableFields.includes(key)) {
-                result.filter = serializeStringOrArray$1("AND", key, opts.exact);
+                result.filter = serializeStringOrArray$2("AND", key, opts.exact);
             }
             else {
                 // Treat it the same as .all
@@ -13620,18 +13620,18 @@
         }
         // Handle the other props
         if (opts.any) {
-            result.q = serializeStringOrArray$1("OR", key, opts.any);
+            result.q = serializeStringOrArray$2("OR", key, opts.any);
         }
         if (opts.all) {
             result.q =
                 (result.q ? result.q + " AND " : "") +
-                    serializeStringOrArray$1("AND", key, opts.all);
+                    serializeStringOrArray$2("AND", key, opts.all);
         }
         if (opts.not) {
             // negate the entries if they are not
             result.q =
                 (result.q ? result.q + " AND " : "") +
-                    serializeStringOrArray$1("OR", "-" + key, opts.not);
+                    serializeStringOrArray$2("OR", "-" + key, opts.not);
         }
         return result;
     }
@@ -13642,7 +13642,7 @@
      * @param range
      * @returns
      */
-    function serializeDateRange$1(key, range) {
+    function serializeDateRange$2(key, range) {
         return {
             q: key + ":[" + range.from + " TO " + range.to + "]",
             filter: "",
@@ -13656,7 +13656,7 @@
      * @param value
      * @returns
      */
-    function serializeStringOrArray$1(join, key, value) {
+    function serializeStringOrArray$2(join, key, value) {
         var q = "";
         if (Array.isArray(value)) {
             q = key + ":\"" + value.join("\" " + join + " " + key + ":\"") + "\"";
@@ -14144,12 +14144,12 @@
                 // from hitting the else
                 /* istanbul ignore else */
                 if (typeof entry === "object") {
-                    acc = mergeSearchOptions$1(acc, convertContentFilterToSearchOptions(entry), "OR");
+                    acc = mergeSearchOptions$2(acc, convertContentFilterToSearchOptions(entry), "OR");
                 }
                 return acc;
             }, { q: "", filter: "" });
             // merge with searchOptions using AND
-            searchOptions = mergeSearchOptions$1(searchOptions, subFilterOptions, "AND");
+            searchOptions = mergeSearchOptions$2(searchOptions, subFilterOptions, "AND");
         }
         // term is always last, and pre-pended on searchOptions.q
         if (filter.term) {
@@ -14177,11 +14177,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions may go into either q or filter
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeMatchOptions$2(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeDateRange$2(key, value), "AND");
             }
         });
         return result;
@@ -14312,11 +14312,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions fields
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeMatchOptions$2(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeDateRange$2(key, value), "AND");
             }
         });
         // searchUserAccess is also a top-level property
@@ -14452,11 +14452,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions fields
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeMatchOptions$2(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$2(result, serializeDateRange$2(key, value), "AND");
             }
         });
         // disabled is also a top-level property
@@ -14974,6 +14974,7 @@
         return catalog;
     }
 
+    // DEPRECATED - REMOVE THIS FILE
     /**
      * Expand a Filter into it's more expressive structure so it can be
      * serialized deterministically.
@@ -15026,7 +15027,7 @@
      */
     function serializeFilterGroupsForPortal(filterGroups) {
         var groupSearchOptions = filterGroups.map(serializeGroup);
-        var result = mergeSearchOptions(groupSearchOptions, "AND");
+        var result = mergeSearchOptions$1(groupSearchOptions, "AND");
         return result;
     }
     /**
@@ -15037,9 +15038,9 @@
     function serializeGroup(filterGroup) {
         var operation = filterGroup.operation || "AND";
         var filters = filterGroup.filters.map(expandFilter);
-        var filterSearchOptions = filters.map(serializeFilter);
+        var filterSearchOptions = filters.map(serializeFilter$1);
         // combine these searchOptions
-        var groupSearchOptions = mergeSearchOptions(filterSearchOptions, operation);
+        var groupSearchOptions = mergeSearchOptions$1(filterSearchOptions, operation);
         //
         if (filters.length > 1) {
             groupSearchOptions.q = "(" + groupSearchOptions.q + ")";
@@ -15051,7 +15052,7 @@
      * @param filter
      * @returns
      */
-    function serializeFilter(filter) {
+    function serializeFilter$1(filter) {
         var dateProps = ["created", "modified"];
         var boolProps = ["isopendata"];
         var passThroughProps = ["searchUserAccess", "searchUserName"];
@@ -15067,11 +15068,11 @@
             var so = { q: "" };
             if (!specialProps.includes(key)) {
                 qCount++;
-                so.q = serializeMatchOptions(key, value);
+                so.q = serializeMatchOptions$1(key, value);
             }
             if (dateProps.includes(key)) {
                 qCount++;
-                so.q = serializeDateRange(key, value);
+                so.q = serializeDateRange$1(key, value);
             }
             if (boolProps.includes(key)) {
                 qCount++;
@@ -15088,13 +15089,13 @@
         })
             .filter(function (e) { return e !== undefined; });
         // merge up all the searchOptions
-        var searchOptions = mergeSearchOptions(opts, "AND");
+        var searchOptions = mergeSearchOptions$1(opts, "AND");
         if (qCount > 1) {
             searchOptions.q = "(" + searchOptions.q + ")";
         }
         return searchOptions;
     }
-    function mergeSearchOptions(options, operation) {
+    function mergeSearchOptions$1(options, operation) {
         var result = options.reduce(function (acc, entry) {
             // walk the props
             Object.entries(entry).forEach(function (_a) {
@@ -15119,21 +15120,21 @@
      * @param value
      * @returns
      */
-    function serializeMatchOptions(key, value) {
+    function serializeMatchOptions$1(key, value) {
         var result = "";
         if (value.any) {
-            result = "" + serializeStringOrArray("OR", key, value.any);
+            result = "" + serializeStringOrArray$1("OR", key, value.any);
         }
         if (value.all) {
             result =
                 (result ? result + " AND " : "") +
-                    ("" + serializeStringOrArray("AND", key, value.all));
+                    ("" + serializeStringOrArray$1("AND", key, value.all));
         }
         if (value.not) {
             // negate the entries if they are not
             result =
                 (result ? result + " AND " : "") +
-                    ("" + serializeStringOrArray("OR", "-" + key, value.not));
+                    ("" + serializeStringOrArray$1("OR", "-" + key, value.not));
         }
         // TODO HANDLE EXACT
         return result;
@@ -15144,7 +15145,7 @@
      * @param range
      * @returns
      */
-    function serializeDateRange(key, range) {
+    function serializeDateRange$1(key, range) {
         return key + ":[" + range.from + " TO " + range.to + "]";
     }
     /**
@@ -15154,7 +15155,7 @@
      * @param value
      * @returns
      */
-    function serializeStringOrArray(join, key, value) {
+    function serializeStringOrArray$1(join, key, value) {
         var q = "";
         if (Array.isArray(value)) {
             q = key + ":\"" + value.join("\" " + join + " " + key + ":\"") + "\"";
@@ -15332,6 +15333,224 @@
         };
     }
 
+    function expandPredicate(predicate) {
+        var result = {};
+        var dateProps = ["created", "modified", "lastlogin"];
+        var copyProps = [
+            "filterType",
+            "term",
+            "searchUserAccess",
+            "isopendata",
+            "searchUserName",
+        ];
+        var nonMatchOptionsFields = __spreadArrays(dateProps, copyProps);
+        // Do the conversion
+        Object.entries(predicate).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            // Handle MatchOptions fields
+            if (!nonMatchOptionsFields.includes(key)) {
+                setProp(key, valueToMatchOptions(value), result);
+            }
+            // Handle Date fields
+            if (dateProps.includes(key)) {
+                var dateFieldValue = cloneObject$1(getProp(predicate, key));
+                if (getProp(predicate, key + ".type") === "relative-date") {
+                    setProp(key, relativeDateToDateRange(dateFieldValue), result);
+                }
+                else {
+                    setProp(key, dateFieldValue, result);
+                }
+            }
+            // Handle fields that are just copied forward
+            if (copyProps.includes(key) && predicate.hasOwnProperty(key)) {
+                setProp(key, value, result);
+            }
+        });
+        return result;
+    }
+    function serializeQueryForPortal(query) {
+        var filterSearchOptions = query.filters.map(serializeFilter);
+        var result = mergeSearchOptions(filterSearchOptions, "AND");
+        return result;
+    }
+    function mergeSearchOptions(options, operation) {
+        var result = options.reduce(function (acc, entry) {
+            // walk the props
+            Object.entries(entry).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                // if prop exists
+                if (acc[key]) {
+                    // combine via operation
+                    acc[key] = acc[key] + " " + operation + " " + value;
+                }
+                else {
+                    // just copy the value
+                    acc[key] = value;
+                }
+            });
+            return acc;
+        }, { q: "" });
+        return result;
+    }
+    /**
+     * Serialize the filters in a FitlerGroup into a Portal Query
+     * @param filter
+     * @returns
+     */
+    function serializeFilter(filter) {
+        var operation = filter.operation || "AND";
+        var predicates = filter.predicates.map(expandPredicate);
+        var predicateSearchOptions = predicates.map(serializePredicate);
+        // combine these searchOptions
+        var searchOptions = mergeSearchOptions(predicateSearchOptions, operation);
+        // wrap in parens if we have more than one predicate
+        if (predicates.length > 1) {
+            searchOptions.q = "(" + searchOptions.q + ")";
+        }
+        return searchOptions;
+    }
+    /**
+     * Serialize a Filter into a Portal Query
+     * @param predicate
+     * @returns
+     */
+    function serializePredicate(predicate) {
+        var dateProps = ["created", "modified"];
+        var boolProps = ["isopendata"];
+        var passThroughProps = ["searchUserAccess", "searchUserName"];
+        var specialProps = __spreadArrays([
+            "filterType",
+            "term"
+        ], dateProps, boolProps, passThroughProps);
+        var portalAllowList = [
+            "access",
+            "categories",
+            "created",
+            "description",
+            "disabled",
+            "email",
+            "emailstatus",
+            "firstname",
+            "fullname",
+            "group",
+            "id",
+            "isInvitationOnly",
+            "isopendata",
+            "joined",
+            "lastlogin",
+            "lastname",
+            "memberType",
+            "modified",
+            "name",
+            "orgid",
+            "orgIds",
+            "owner",
+            "provider",
+            "role",
+            "searchUserAccess",
+            "searchUserName",
+            "snippet",
+            "tags",
+            "term",
+            "type",
+            "typekeywords",
+            "userlicensetype",
+            "username",
+        ];
+        var qCount = 0;
+        // TODO: Look at using reduce vs .map and remove the `.filter`
+        var opts = Object.entries(predicate)
+            .map(function (_a) {
+            var key = _a[0], value = _a[1];
+            // When serializing for portal we limit predicate properties to
+            // a list of known properties that the portal api accepts. This will
+            // not attempt to ensure the properties are used in the correct combinations
+            if (portalAllowList.includes(key)) {
+                var so = { q: "" };
+                if (!specialProps.includes(key)) {
+                    qCount++;
+                    so.q = serializeMatchOptions(key, value);
+                }
+                if (dateProps.includes(key)) {
+                    qCount++;
+                    so.q = serializeDateRange(key, value);
+                }
+                if (boolProps.includes(key)) {
+                    qCount++;
+                    so.q = key + ":" + value;
+                }
+                if (passThroughProps.includes(key)) {
+                    so[key] = value;
+                }
+                if (key === "term") {
+                    qCount++;
+                    so.q = value;
+                }
+                return so;
+            }
+        })
+            .filter(function (e) { return e !== undefined; });
+        // merge up all the searchOptions
+        var searchOptions = mergeSearchOptions(opts, "AND");
+        if (qCount > 1) {
+            searchOptions.q = "(" + searchOptions.q + ")";
+        }
+        return searchOptions;
+    }
+    /**
+     * Serialize MatchOptions into portal syntax
+     * @param key
+     * @param value
+     * @returns
+     */
+    function serializeMatchOptions(key, value) {
+        var result = "";
+        if (value.any) {
+            result = "" + serializeStringOrArray("OR", key, value.any);
+        }
+        if (value.all) {
+            result =
+                (result ? result + " AND " : "") +
+                    ("" + serializeStringOrArray("AND", key, value.all));
+        }
+        if (value.not) {
+            // negate the entries if they are not
+            result =
+                (result ? result + " AND " : "") +
+                    ("" + serializeStringOrArray("OR", "-" + key, value.not));
+        }
+        return result;
+    }
+    /**
+     * Serialize a date-range into Portal syntax
+     * @param key
+     * @param range
+     * @returns
+     */
+    function serializeDateRange(key, range) {
+        return key + ":[" + range.from + " TO " + range.to + "]";
+    }
+    /**
+     * Serialize a `string` or `string[]` into a string
+     * @param join
+     * @param key
+     * @param value
+     * @returns
+     */
+    function serializeStringOrArray(join, key, value) {
+        var q = "";
+        if (Array.isArray(value)) {
+            q = key + ":\"" + value.join("\" " + join + " " + key + ":\"") + "\"";
+            if (value.length > 1) {
+                q = "(" + q + ")";
+            }
+        }
+        else {
+            q = key + ":\"" + value + "\"";
+        }
+        return q;
+    }
+
     /**
      * Fetch Page specific Enrichments
      * @param item
@@ -17849,12 +18068,34 @@
 
     /**
      * @private
-     * Portal Search Implementation for Items
+     * Convert a portal aggregation structure into the HubAggregations structure
+     * @param searchResults
+     * @returns
+     */
+    function convertPortalAggregations(searchResults) {
+        var _a;
+        if ((_a = searchResults.aggregations) === null || _a === void 0 ? void 0 : _a.counts) {
+            return searchResults.aggregations.counts.map(function (entry) {
+                return {
+                    mode: "terms",
+                    field: entry.fieldName,
+                    values: entry.fieldValues,
+                };
+            });
+        }
+        else {
+            return [];
+        }
+    }
+
+    /**
+     * @private
+     * DEPRECATED
      * @param filterGroups
      * @param options
      * @returns
      */
-    function portalSearchItems(filterGroups, options) {
+    function portalSearchItemsFilterGroups(filterGroups, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
             var replaced, expandedGroups, so, props;
@@ -17862,7 +18103,7 @@
                 if (!options.requestOptions) {
                     throw new HubError$1("hubSearch", "requestOptions: IHubRequestOptions is required.");
                 }
-                replaced = applyWellKnownItemFilters(filterGroups);
+                replaced = applyWellKnownItemFilterGroups(filterGroups);
                 expandedGroups = replaced.map(function (fg) {
                     fg.filters = fg.filters.map(expandFilter);
                     return fg;
@@ -17897,6 +18138,57 @@
             });
         });
     }
+    /**
+     * @private
+     * Portal Search Implementation for Items
+     * @param query
+     * @param options
+     * @returns
+     */
+    function portalSearchItems(query, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var updatedQuery, so, props;
+            return __generator(this, function (_b) {
+                if (!options.requestOptions) {
+                    throw new HubError$1("portalSearchItems", "options.requestOptions is required.");
+                }
+                updatedQuery = applyWellKnownItemPredicates(query);
+                // Expand the individual predicates in each filter
+                updatedQuery.filters = updatedQuery.filters.map(function (filter) {
+                    filter.predicates = filter.predicates.map(expandPredicate);
+                    return filter;
+                });
+                so = serializeQueryForPortal(updatedQuery);
+                props = [
+                    "num",
+                    "sortField",
+                    "sortOrder",
+                    "include",
+                    "start",
+                    "requestOptions",
+                ];
+                // copy the props over
+                props.forEach(function (prop) {
+                    if (options.hasOwnProperty(prop)) {
+                        so[prop] = options[prop];
+                    }
+                });
+                if (options.requestOptions.authentication) {
+                    so.authentication = options.requestOptions.authentication;
+                }
+                else {
+                    so.portal = options.requestOptions.portal;
+                }
+                // Aggregations
+                if ((_a = options.aggFields) === null || _a === void 0 ? void 0 : _a.length) {
+                    so.countFields = options.aggFields.join(",");
+                    so.countSize = options.aggLimit || 10;
+                }
+                return [2 /*return*/, searchPortal$2(so)];
+            });
+        });
+    }
     /**
      * Internal portal search, which then converts `IItem`s to `IHubSearchResult`s
      * handling enrichments & includes along the way
@@ -17906,7 +18198,7 @@
      */
     function searchPortal$2(searchOptions) {
         return __awaiter(this, void 0, void 0, function () {
-            var resp, fn, results, facets;
+            var resp, fn, results, facets, aggregations;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, searchItems(searchOptions)];
@@ -17919,11 +18211,13 @@
                     case 2:
                         results = _a.sent();
                         facets = convertPortalItemResponseToFacets(resp);
+                        aggregations = convertPortalAggregations(resp);
                         // Construct the return
                         return [2 /*return*/, {
                                 total: resp.total,
                                 results: results,
                                 facets: facets,
+                                aggregations: aggregations,
                                 hasNext: resp.nextStart > -1,
                                 next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$2),
                             }];
@@ -18137,7 +18431,36 @@
      * Only exported to enable extensive testing
      * @param filterGroups
      */
-    function applyWellKnownItemFilters(filterGroups) {
+    function applyWellKnownItemPredicates(query) {
+        var queryClone = cloneObject$1(query);
+        // iterate the filters
+        queryClone.filters = queryClone.filters.map(function (filter) {
+            // replace predicates with well-known types
+            filter.predicates = filter.predicates.reduce(function (acc, predicate) {
+                // if the predicate has a well-known type
+                // we replace it with the set of predicates defined
+                // for the well-known type
+                if (isWellKnownTypeFilter(predicate.type)) {
+                    var replacements = lookupTypePredicates(predicate.type);
+                    acc = __spreadArrays(acc, replacements);
+                }
+                else {
+                    // this predicate does not have a well-known type
+                    // so we just keep it
+                    acc.push(predicate);
+                }
+                return acc;
+            }, []);
+            return filter;
+        });
+        return queryClone;
+    }
+    /**
+     * DEPRECATED
+     * @param filterGroups
+     * @returns
+     */
+    function applyWellKnownItemFilterGroups(filterGroups) {
         var clone = cloneObject$1(filterGroups);
         // iterate the filterGroups
         var result = clone.map(function (filterGroup) {
@@ -18189,6 +18512,16 @@
     function lookupTypeFilters(key) {
         return WellKnownItemFilters[key];
     }
+    function lookupTypePredicates(key) {
+        var rawPredicates = WellKnownItemFilters[key];
+        // Remove the filterType property as it's not needed in an IPredicate
+        var predicates = rawPredicates.map(function (entry) {
+            var c = cloneObject$1(entry);
+            delete c.filterType;
+            return c;
+        });
+        return predicates;
+    }
 
     // ##    ##  #######  ######## ########
     // ###   ## ##     ##    ##    ##
@@ -18392,12 +18725,13 @@
 
     /**
      * @private
-     * Portal Search Implementation for Items
+     * DEPRECATED: Use `portalSerchGroups`
+     * Portal Search Implementation for Groups
      * @param filterGroups
      * @param options
      * @returns
      */
-    function portalSearchGroups(filterGroups, options) {
+    function portalSearchGroupsFilterGroups(filterGroups, options) {
         return __awaiter(this, void 0, void 0, function () {
             var api, expandedGroups, so, props;
             return __generator(this, function (_a) {
@@ -18444,6 +18778,51 @@
             });
         });
     }
+    /**
+     * @private
+     * Portal Search Implementation for Groups
+     * @param query
+     * @param options
+     * @returns
+     */
+    function portalSearchGroups(query, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var so, props;
+            return __generator(this, function (_a) {
+                if (!options.requestOptions) {
+                    throw new HubError$1("portalSearchGroups", "options.requestOptions is required.");
+                }
+                // Expand the individual predicates in each filter
+                query.filters = query.filters.map(function (filter) {
+                    filter.predicates = filter.predicates.map(expandPredicate);
+                    return filter;
+                });
+                so = serializeQueryForPortal(query);
+                props = [
+                    "num",
+                    "sortField",
+                    "sortOrder",
+                    "include",
+                    "start",
+                    "requestOptions",
+                ];
+                // copy the props over
+                props.forEach(function (prop) {
+                    if (options.hasOwnProperty(prop)) {
+                        so[prop] = options[prop];
+                    }
+                });
+                // If we don't have auth, ensure we have .portal
+                if (options.requestOptions.authentication) {
+                    so.authentication = options.requestOptions.authentication;
+                }
+                else {
+                    so.portal = options.requestOptions.portal;
+                }
+                return [2 /*return*/, searchPortal$1(so)];
+            });
+        });
+    }
     /**
      * Internal portal search, which then converts `IGroup`s to `IHubSearchResult`s
      * handling enrichments & includes along the way
@@ -18501,11 +18880,12 @@
 
     /**
      * @private
+     * DEPRECATED: Use `portalSearchUsers`
      * Portal Search implementation for Users
      * @param filterGroups
      * @param options
      */
-    function portalSearchUsers(filterGroups, options) {
+    function portalSearchUsersFilterGroups(filterGroups, options) {
         return __awaiter(this, void 0, void 0, function () {
             var expandedGroups, so, props;
             return __generator(this, function (_a) {
@@ -18542,6 +18922,52 @@
             });
         });
     }
+    /**
+     * @private
+     * Portal Search Implementation for Users
+     * @param filterGroups
+     * @param options
+     * @returns
+     */
+    function portalSearchUsers(query, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var so, props;
+            return __generator(this, function (_a) {
+                // requestOptions is always required and user must be authd
+                if (!options.requestOptions) {
+                    throw new HubError$1("portalSearchUsers", "requestOptions: IHubRequestOptions is required.");
+                }
+                if (!options.requestOptions.authentication) {
+                    throw new HubError$1("portalSearchUsers", "requestOptions must pass authentication.");
+                }
+                // Expand the individual predicates in each filter
+                query.filters = query.filters.map(function (filter) {
+                    filter.predicates = filter.predicates.map(expandPredicate);
+                    return filter;
+                });
+                so = serializeQueryForPortal(query);
+                props = [
+                    "num",
+                    "sortField",
+                    "sortOrder",
+                    "include",
+                    "start",
+                    "requestOptions",
+                ];
+                // copy the props over
+                props.forEach(function (prop) {
+                    if (options.hasOwnProperty(prop)) {
+                        so[prop] = options[prop];
+                    }
+                });
+                // Unlike Groups and Item, the Users api *requires* authentication
+                // so we set it directly
+                so.authentication = options.requestOptions.authentication;
+                // Execute search
+                return [2 /*return*/, searchPortal(so)];
+            });
+        });
+    }
     /**
      * Internal portal search, which then converts `IGroup`s to `IHubSearchResult`s
      * handling enrichments & includes along the way
@@ -18626,6 +19052,53 @@
                 }
                 filterType = filterGroups[0].filterType;
                 apiType = expandApi(options.api || "arcgis").type;
+                fnHash = {
+                    arcgis: {
+                        item: portalSearchItemsFilterGroups,
+                        group: portalSearchGroupsFilterGroups,
+                        user: portalSearchUsersFilterGroups,
+                    },
+                    "arcgis-hub": {
+                        item: hubSearchItems,
+                    },
+                };
+                fn = getProp(fnHash, apiType + "." + filterType);
+                if (!fn) {
+                    throw new HubError$1("hubSearch", "Search via \"" + filterType + "\" filter against \"" + apiType + "\" api is not implemented");
+                }
+                return [2 /*return*/, fn(cloneObject$1(filterGroups), options)];
+            });
+        });
+    }
+    /**
+     * Main entrypoint for searching via Hub
+     *
+     * Default's to search ArcGIS Portal but can delegate
+     * to Hub API when it's available.
+     * @param query
+     * @param options
+     * @returns
+     */
+    function hubSearchQuery(query, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filterType, apiType, fnHash, fn;
+            return __generator(this, function (_a) {
+                // Validate inputs
+                if (!query) {
+                    throw new HubError$1("hubSearch", "Query is required.");
+                }
+                if (!query.filters || !query.filters.length) {
+                    throw new HubError$1("hubSearch", "Query must contain at least one Filter.");
+                }
+                if (!options.requestOptions) {
+                    throw new HubError$1("hubSearch", "requestOptions: IHubRequestOptions is required.");
+                }
+                // Ensure includes is an array
+                if (!options.include) {
+                    options.include = [];
+                }
+                filterType = query.targetEntity;
+                apiType = expandApi(options.api || "arcgis").type;
                 fnHash = {
                     arcgis: {
                         item: portalSearchItems,
@@ -18640,7 +19113,7 @@
                 if (!fn) {
                     throw new HubError$1("hubSearch", "Search via \"" + filterType + "\" filter against \"" + apiType + "\" api is not implemented");
                 }
-                return [2 /*return*/, fn(cloneObject$1(filterGroups), options)];
+                return [2 /*return*/, fn(cloneObject$1(query), options)];
             });
         });
     }
@@ -20479,6 +20952,7 @@
     exports.hubApiRequest = hubApiRequest;
     exports.hubApiSearch = hubApiSearch;
     exports.hubSearch = hubSearch;
+    exports.hubSearchQuery = hubSearchQuery;
     exports.includes = includes;
     exports.incrementString = incrementString;
     exports.interpolate = interpolate;
@@ -20513,7 +20987,7 @@
     exports.mergeGroupFilters = mergeGroupFilters;
     exports.mergeMatchOptions = mergeMatchOptions;
     exports.mergeObjects = mergeObjects;
-    exports.mergeSearchOptions = mergeSearchOptions$1;
+    exports.mergeSearchOptions = mergeSearchOptions$2;
     exports.mergeUserFilters = mergeUserFilters;
     exports.normalizeItemType = normalizeItemType;
     exports.normalizeSolutionTemplateItem = normalizeSolutionTemplateItem;
@@ -20538,13 +21012,13 @@
     exports.searchSites = searchSites;
     exports.serializeCollectionState = serializeCollectionState;
     exports.serializeContentFilterForPortal = serializeContentFilterForPortal;
-    exports.serializeDateRange = serializeDateRange$1;
+    exports.serializeDateRange = serializeDateRange$2;
     exports.serializeFilterGroupsForPortal = serializeFilterGroupsForPortal;
     exports.serializeGroupFilterForPortal = serializeGroupFilterForPortal;
-    exports.serializeMatchOptions = serializeMatchOptions$1;
+    exports.serializeMatchOptions = serializeMatchOptions$2;
     exports.serializeModel = serializeModel;
     exports.serializeSpatialReference = serializeSpatialReference;
-    exports.serializeStringOrArray = serializeStringOrArray$1;
+    exports.serializeStringOrArray = serializeStringOrArray$2;
     exports.serializeUserFilterForPortal = serializeUserFilterForPortal;
     exports.setContentHubId = setContentHubId;
     exports.setContentSiteUrls = setContentSiteUrls;