@esri/hub-common 9.3.0 → 9.4.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.2.0 - Wed Oct 27 2021 08:57:00 GMT-0600 (Mountain Daylight Time)
+ * @esri/hub-common - v9.3.0 - Thu Oct 28 2021 14:17:26 GMT-0600 (Mountain Daylight Time)
  * Copyright (c) 2021 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -7979,6 +7979,828 @@
         return hubApiRequest("/search", __assign(__assign({}, defaults), requestOptions));
     }
 
+    /* Copyright (c) 2018-2021 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * Well known APIs
+     * Short-forms for specifying common APIs
+     */
+    var SEARCH_APIS = {
+        arcgis: {
+            label: "ArcGIS Online",
+            url: "https://www.arcgis.com",
+            type: "arcgis",
+        },
+        arcgisQA: {
+            label: "ArcGIS Online QAEXT",
+            url: "https://qaext.arcgis.com",
+            type: "arcgis",
+        },
+        arcgisDEV: {
+            label: "ArcGIS Online DEVEXT",
+            url: "https://devext.arcgis.com",
+            type: "arcgis",
+        },
+        hub: {
+            label: "ArcGIS Hub",
+            url: "https://hub.arcgis.com/api",
+            type: "arcgis-hub",
+        },
+        hubDEV: {
+            label: "ArcGIS Hub DEV",
+            url: "https://hubdev.arcgis.com/api",
+            type: "arcgis-hub",
+        },
+        hubQA: {
+            label: "ArcGIS Hub QA",
+            url: "https://hubqa.arcgis.com/api",
+            type: "arcgis-hub",
+        },
+    };
+    /**
+     * @private
+     * Convert api "names" into full ApiDefinitions
+     * @param apis
+     * @returns
+     */
+    function expandApis(apis) {
+        return apis.map(function (api) {
+            if (typeof api === "string" && api in SEARCH_APIS) {
+                return SEARCH_APIS[api];
+            }
+            else {
+                // it's an object, so we trust that it's well formed
+                return api;
+            }
+        });
+    }
+    /**
+     * @private
+     * Merge multiple search responses
+     *
+     * Naieve implementation that just merges arrays
+     * @param responses
+     * @returns
+     */
+    function mergeSearchResults(responses) {
+        // Merge content
+        var content = responses.reduce(function (acc, response) {
+            if (response.content) {
+                acc = acc.concat(response.content);
+            }
+            return acc;
+        }, []);
+        // Merge Facets
+        var facets = responses.reduce(function (acc, response) {
+            if (response.facets) {
+                acc = acc.concat(response.facets);
+            }
+            return acc;
+        }, []);
+        return { content: content, facets: facets };
+    }
+    /**
+     * @private
+     * Merge two date ranges by taking the longest span
+     * @param dr1
+     * @param dr2
+     * @returns
+     */
+    function mergeDateRange(dr1, dr2) {
+        var result = cloneObject$1(dr1);
+        // feels like there is a more concise way to do this...
+        if (dr2.from < dr1.from) {
+            result.from = dr2.from;
+        }
+        if (dr2.to > dr1.to) {
+            result.to = dr2.to;
+        }
+        return result;
+    }
+    /**
+     * @private
+     * Merge two [`MatchOptions`](../MatchOptions)
+     *
+     * Currently a naieve implementation where the arrays are simply merged
+     *
+     * @param mo1
+     * @param mo2
+     * @returns
+     */
+    function mergeMatchOptions(mo1, mo2) {
+        var result = {};
+        // None of these props are required, so we can't just
+        // use Object.keys/.entries
+        var props = ["any", "all", "not", "exact"];
+        props.forEach(function (prop) {
+            var key = prop;
+            var merged = __spreadArrays(getMatchValue(mo1, key), getMatchValue(mo2, key));
+            if (merged.length) {
+                // remove any dupes and set on the return
+                result[key] = merged.filter(unique);
+            }
+        });
+        return result;
+    }
+    /**
+     * Get the value of a property on an IMatchOptions
+     *
+     * This is complex b/c all the props are optional, and
+     * they could be a simple string, or an array of strings.
+     *
+     * This function normalizes all that and returns an array,
+     * which may or may not be empty
+     * @param option
+     * @param key
+     * @returns
+     */
+    function getMatchValue(option, key) {
+        var matchValue = [];
+        if (option[key]) {
+            var val = option[key];
+            if (Array.isArray(val)) {
+                matchValue = val;
+            }
+            else {
+                matchValue = [val];
+            }
+        }
+        return matchValue;
+    }
+    /**
+     * @private
+     * Convert a field value into a MatchOptions if it's not already one
+     * @param value
+     * @returns
+     */
+    function valueToMatchOptions(value) {
+        var result = {};
+        if (Array.isArray(value)) {
+            result = {
+                any: value,
+            };
+        }
+        else {
+            if (typeof value === "string") {
+                result = {
+                    any: [value],
+                };
+            }
+            if (typeof value === "object") {
+                result = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * @private
+     * Convert a RelativeDate to a DateRange<number>
+     * @param relative
+     * @returns
+     */
+    function relativeDateToDateRange(relative) {
+        // hash of offsets
+        var offsetMs = {
+            min: 1000 * 60,
+            hours: 1000 * 60 * 60,
+            days: 1000 * 60 * 60 * 24,
+            weeks: 1000 * 60 * 60 * 24 * 7,
+        };
+        var now = new Date();
+        // default
+        var result = {
+            type: "date-range",
+            from: now.getTime(),
+            to: now.getTime(),
+        };
+        //
+        switch (relative.unit) {
+            case "hours":
+            case "days":
+            case "weeks":
+                result.from = result.to - offsetMs[relative.unit] * relative.num;
+                break;
+            case "months":
+                // get the current month and subtract num
+                now.setMonth(now.getMonth() - relative.num);
+                result.from = now.getTime();
+                break;
+            case "years":
+                now.setFullYear(now.getFullYear() - relative.num);
+                result.from = now.getTime();
+                break;
+        }
+        return result;
+    }
+    /**
+     * @private
+     * As a final `ISearchOptions` object gets created, many such objects are created, and
+     * need to be systematically "merged" so as to return consistently structured `q` and `filter`
+     * values.
+     * @param so1
+     * @param so2
+     * @param join
+     * @returns
+     */
+    function mergeSearchOptions(so1, so2, join) {
+        var result = cloneObject$1(so1);
+        var q = so2.q, filter = so2.filter;
+        if (q) {
+            result.q = (result.q ? " (" + result.q + " " + join + " " + q + ")" : q).trim();
+        }
+        if (filter) {
+            result.filter = (result.filter ? "(" + result.filter + " " + join + " " + filter + ")" : filter).trim();
+        }
+        return result;
+    }
+    /**
+     * @private
+     * Serialize a `MatchOptions` into `q` or `filter` on an `ISearchOptions`
+     * @param key
+     * @param opts
+     * @returns
+     */
+    function serializeMatchOptions(key, opts) {
+        var result = {
+            q: "",
+            filter: "",
+        };
+        if (opts.exact) {
+            // defined separately for refactoring later
+            var userFilterableFields = [
+                "username",
+                "firstname",
+                "lastname",
+                "fullname",
+                "email",
+            ];
+            var itemFilterableFields = [
+                "title",
+                "tags",
+                "typekeywords",
+                "type",
+                "name",
+                "owner",
+            ];
+            var groupFilterableFields = ["title", "typekeywords", "owner"];
+            var filterableFields = __spreadArrays(userFilterableFields, itemFilterableFields, groupFilterableFields);
+            if (filterableFields.includes(key)) {
+                result.filter = serializeStringOrArray("AND", key, opts.exact);
+            }
+            else {
+                // Treat it the same as .all
+                if (typeof opts.exact === "string") {
+                    if (!opts.all) {
+                        opts.all = [];
+                    }
+                    if (typeof opts.all === "string") {
+                        opts.all = [opts.all];
+                    }
+                    opts.all.push(opts.exact);
+                }
+                if (Array.isArray(opts.exact)) {
+                    if (!opts.all) {
+                        opts.all = [];
+                    }
+                    if (typeof opts.all === "string") {
+                        opts.all = [opts.all];
+                    }
+                    opts.all = opts.all.concat(opts.exact);
+                }
+            }
+        }
+        // Handle the other props
+        if (opts.any) {
+            result.q = serializeStringOrArray("OR", key, opts.any);
+        }
+        if (opts.all) {
+            result.q =
+                (result.q ? result.q + " AND " : "") +
+                    serializeStringOrArray("AND", key, opts.all);
+        }
+        if (opts.not) {
+            // negate the entries if they are not
+            result.q =
+                (result.q ? result.q + " AND " : "") +
+                    serializeStringOrArray("OR", "-" + key, opts.not);
+        }
+        return result;
+    }
+    /**
+     * @private
+     * Serialize a DateRange<number> into a Portal Query string
+     * @param key
+     * @param range
+     * @returns
+     */
+    function serializeDateRange(key, range) {
+        return {
+            q: key + ":[" + range.from + " TO " + range.to + "]",
+            filter: "",
+        };
+    }
+    /**
+     * @private
+     * 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 + ":\"") + "\")";
+        }
+        else {
+            q = key + ":\"" + value + "\"";
+        }
+        return q;
+    }
+
+    // TODO: Implement $dataset
+    var ContentFilterExpansions = {
+        $apps: [
+            {
+                type: {
+                    any: [
+                        "Code Sample",
+                        "Web Mapping Application",
+                        "Mobile Application",
+                        "Application",
+                        "Desktop Application Template",
+                        "Desktop Application",
+                        "Operation View",
+                        "Dashboard",
+                        "Operations Dashboard Extension",
+                        "Workforce Project",
+                        "Insights Workbook",
+                        "Insights Page",
+                        "Insights Model",
+                        "Hub Page",
+                        "Hub Initiative",
+                        "Hub Site Application",
+                        "StoryMap",
+                        "Web Experience",
+                        "Web Experience Template",
+                        "Form",
+                    ],
+                    not: [
+                        "Code Attachment",
+                        "Featured Items",
+                        "Symbol Set",
+                        "Color Set",
+                        "Windows Viewer Add In",
+                        "Windows Viewer Configuration",
+                        "Map Area",
+                        "Indoors Map Configuration",
+                    ],
+                },
+                typekeywords: {
+                    not: ["MapAreaPackage", "SMX"],
+                },
+            },
+        ],
+        $storymap: [
+            {
+                type: "StoryMap",
+            },
+            {
+                type: "Web Mapping Application",
+                typekeywords: ["Story Map"],
+            },
+        ],
+        $dashboard: [
+            {
+                type: "Dashboard",
+                typekeywords: {
+                    any: ["Dashboard"],
+                    not: ["ArcGIS Operation View", "Add In", "Extension"],
+                },
+            },
+        ],
+        $dataset: [],
+        $experience: [
+            {
+                type: {
+                    any: ["Web Experience"],
+                    not: ["Web Experience Template"],
+                },
+            },
+        ],
+        $site: [
+            {
+                type: ["Hub Site Application", "Site Application"],
+            },
+            {
+                type: ["Web Mapping Application"],
+                typekeywords: ["hubSite"],
+            },
+        ],
+        $initiative: [
+            {
+                type: {
+                    any: "Hub Initiative",
+                    not: "Hub Initiative Template",
+                },
+            },
+        ],
+        $document: [
+            {
+                typekeywords: {
+                    any: "Document",
+                    not: ["MapAreaPackage", "SMX"],
+                },
+                type: {
+                    any: [
+                        "Image",
+                        "Layout",
+                        "Desktop Style",
+                        "Project Template",
+                        "Report Template",
+                        "Pro Report",
+                        "Statistical Data Collection",
+                        "360 VR Experience",
+                        "netCDF",
+                        "PDF",
+                        "CSV",
+                        "Administrative Report",
+                        "Raster function template",
+                    ],
+                    not: [
+                        "Image Service",
+                        "Explorer Document",
+                        "Explorer Map",
+                        "Globe Document",
+                        "Scene Document",
+                        "Code Attachment",
+                        "Featured Items",
+                        "Symbol Set",
+                        "ColorSet",
+                        "Windows Viewer Add In",
+                        "Windows Viewer Configuration",
+                        "Map Area",
+                        "Indoors Map Configuration",
+                    ],
+                },
+            },
+        ],
+    };
+    /**
+     * @private
+     * Convert portal search response to items
+     * @param response
+     * @returns
+     */
+    function convertPortalResponseToFacets(response) {
+        var _a;
+        var result = [];
+        if ((_a = response.aggregations) === null || _a === void 0 ? void 0 : _a.counts) {
+            response.aggregations.counts.forEach(function (entry) {
+                var facet = {
+                    label: entry.fieldName,
+                    attribute: entry.fieldName,
+                    type: "multi-select",
+                };
+                var options = [];
+                entry.fieldValues.forEach(function (fv) {
+                    var filter = {
+                        filterType: "content",
+                    };
+                    filter[entry.fieldName] = fv.value;
+                    var fo = {
+                        label: fv.value,
+                        value: fv.value,
+                        count: fv.count,
+                        selected: false,
+                        filter: filter,
+                    };
+                    options.push(fo);
+                });
+                facet.options = options;
+                result.push(facet);
+            });
+        }
+        return result;
+    }
+    /**
+     * @private
+     * Merge `Filter<"content">` objects
+     * @param filters
+     * @returns
+     */
+    function mergeContentFilter(filters) {
+        // expand all the filters so all prop types are consistent
+        var expanded = filters.map(expandContentFilter);
+        // now we can merge based on fields
+        var dateFields = ["created", "modified"];
+        var specialFields = __spreadArrays(["filterType", "subFilters"], dateFields);
+        var result = expanded.reduce(function (acc, entry) {
+            // process fields
+            Object.entries(entry).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                // MatchOption fields
+                if (!specialFields.includes(key)) {
+                    if (acc[key]) {
+                        acc[key] = mergeMatchOptions(acc[key], value);
+                    }
+                    else {
+                        acc[key] = cloneObject$1(value);
+                    }
+                }
+                // Dates
+                if (dateFields.includes(key)) {
+                    if (acc[key]) {
+                        acc[key] = mergeDateRange(acc[key], value);
+                    }
+                    else {
+                        acc[key] = cloneObject$1(value);
+                    }
+                }
+                // SubFilters
+                if (key === "subFilters" && Array.isArray(value)) {
+                    if (acc.subFilters) {
+                        acc.subFilters = mergeSubFilters(acc.subFilters, value);
+                    }
+                    else {
+                        acc.subFilters = cloneObject$1(value);
+                    }
+                }
+            });
+            return acc;
+        }, {});
+        result.filterType = "content";
+        return result;
+    }
+    function mergeSubFilters(sf1, sf2) {
+        // Simplistic implementation: we just merge the arrays
+        // in the future we may try to de-dupe things as a safeguard
+        return __spreadArrays(sf1, sf2);
+    }
+    /**
+     * Prior to serialization into the query syntax for the backing APIs, we first expand [Filters](../Filter)
+     *
+     * Filter's can express their intent in a very terse form, but to ensure consistent
+     * into their more verbose form.
+     *
+     * i.e. `title: "Water"` expands into `title: { any: ["Water"]}`
+     *
+     * - "well known" type values are expanded
+     *    - i.e. `type: "$storymap"` expands into two `subFilter` entries
+     * - Fields defined as `string | string[] | MatchOptions` will be converted to a `MatchOptions`
+     * - RelativeDate fields are converted to DateRange<number>
+     *
+     * @param filter
+     * @returns
+     */
+    function expandContentFilter(filter) {
+        // Expand filter.type first
+        var expandedTypeFilter = expandTypeField(filter);
+        // Expand subfilters
+        // Guard - JS Clients could send in anything...
+        if (Array.isArray(filter.subFilters)) {
+            // Convert any strings into the coresponding ContentFilterDefinition
+            expandedTypeFilter.subFilters = expandedTypeFilter.subFilters.reduce(function (acc, entry) {
+                if (typeof entry === "string") {
+                    // if the entry is not a key of ContentFilterExpansions
+                    // we just skip over it
+                    if (ContentFilterExpansions[entry]) {
+                        acc = acc.concat(ContentFilterExpansions[entry]);
+                    }
+                }
+                else {
+                    acc.push(entry); // should be a ContentFilterDefinition
+                }
+                return acc;
+            }, []);
+        }
+        // Convert all props into MatchOptions/DateRanges
+        return convertContentDefinitionToFilter(expandedTypeFilter);
+    }
+    /**
+     * @private
+     * Expand from a well-known "type" into it's longer form
+     *
+     * i.e. `type: "$storymap"` expands into two subFilters entries
+     *
+     * @param filter
+     * @returns
+     */
+    function expandTypeField(filter) {
+        var clone = cloneObject$1(filter);
+        // ensure subFilters is defined as an array
+        clone.subFilters = clone.subFilters || [];
+        if (clone.type) {
+            // if .type is an Array...
+            if (Array.isArray(clone.type)) {
+                // remove any well-known-keys and move their expansions into subfilters
+                clone.type = clone.type.reduce(function (acc, entry) {
+                    if (isWellKnownType(entry)) {
+                        // working with dynamic objects in typescript requires some assertions
+                        var key = entry;
+                        clone.subFilters = clone.subFilters.concat(lookupTypeFilters(key));
+                    }
+                    else {
+                        acc.push(entry);
+                    }
+                    return acc;
+                }, []);
+            }
+            else if (isWellKnownType(clone.type)) {
+                var key = clone.type;
+                clone.subFilters = clone.subFilters.concat(lookupTypeFilters(key));
+                delete clone.type;
+            }
+            else ;
+        }
+        return clone;
+    }
+    /**
+     * Is the argument a well-known type "key"
+     *
+     * Accepts `string`, `string[]` or `IMatchOptions`
+     * but only string values can possibly be properties
+     * on `ContentFilterExpansions`
+     * @param key
+     * @returns
+     */
+    function isWellKnownType(key) {
+        var result = false;
+        if (typeof key === "string") {
+            result = key in ContentFilterExpansions;
+        }
+        return result;
+    }
+    function lookupTypeFilters(key) {
+        return ContentFilterExpansions[key];
+    }
+    /**
+     * @private
+     * Convert a `ContentFilterDefinition` to a `ContentFilter`
+     *
+     * ContentFilter is a narrower version of ContentFilterDefinition, without
+     * the union types. Using a ContentFilter makes working with the structure
+     * in typescript much easier.
+     *
+     * @param filter
+     * @returns
+     */
+    function convertContentDefinitionToFilter(filter) {
+        var result = {};
+        if (filter.term) {
+            result.term = filter.term;
+        }
+        var dateProps = ["created", "modified"];
+        // Some properties should not get converted to MatchOptions
+        var specialProps = __spreadArrays(["filterType", "subFilters", "term"], dateProps);
+        // Do the conversion
+        Object.entries(filter).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            if (!specialProps.includes(key)) {
+                result[key] = valueToMatchOptions(value);
+            }
+        });
+        // Special Cases
+        // subFilters; Array of ContentFilterDefinitions
+        if (filter.subFilters && Array.isArray(filter.subFilters)) {
+            // downcast - would be nice to skip this or use some other constuct
+            var sf = filter.subFilters;
+            result.subFilters = sf.map(convertContentDefinitionToFilter);
+        }
+        // Dates; Ensure they are all DateRange<number>
+        dateProps.forEach(function (fld) {
+            if (filter[fld]) {
+                if (filter[fld].type === "relative-date") {
+                    result[fld] = relativeDateToDateRange(filter[fld]);
+                }
+                else {
+                    result[fld] = cloneObject$1(filter[fld]);
+                }
+            }
+        });
+        return result;
+    }
+    /**
+     * @private
+     * Serialize a `ContentFilter` into an `ISearchOptions` for use with `searchItems`
+     * @param filter
+     * @returns
+     */
+    function serializeContentFilterForPortal(filter) {
+        var searchOptions = convertContentFilterToSearchOptions(filter);
+        if (filter.subFilters) {
+            var subFilterOptions = filter.subFilters.reduce(function (acc, entry) {
+                // Next guard is present b/c this can be used from javascript
+                // but our tests are written in typescript which prevents us
+                // from hitting the else
+                /* istanbul ignore else */
+                if (typeof entry === "object") {
+                    acc = mergeSearchOptions(acc, convertContentFilterToSearchOptions(entry), "OR");
+                }
+                return acc;
+            }, { q: "", filter: "" });
+            // merge with searchOptions using AND
+            searchOptions = mergeSearchOptions(searchOptions, subFilterOptions, "AND");
+        }
+        // term is always last, and pre-pended on searchOptions.q
+        if (filter.term) {
+            searchOptions.q = (filter.term + " " + searchOptions.q).trim();
+        }
+        return searchOptions;
+    }
+    /**
+     * @private
+     * Convert a ContentFilter to a SearchOptions
+     *
+     * @param filter
+     * @returns
+     */
+    function convertContentFilterToSearchOptions(filter) {
+        var result = {
+            q: "",
+            filter: "",
+        };
+        var dateProps = ["created", "modified"];
+        var specialProps = __spreadArrays(["filterType", "subFilters", "term"], dateProps);
+        Object.entries(filter).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            // MatchOptions may go into either q or filter
+            if (!specialProps.includes(key)) {
+                result = mergeSearchOptions(result, serializeMatchOptions(key, value), "AND");
+            }
+            // Dates only go into q
+            if (dateProps.includes(key)) {
+                result = mergeSearchOptions(result, serializeDateRange(key, value), "AND");
+            }
+        });
+        return result;
+    }
+
+    /**
+     * Search for content via the Portal or Hub API
+     * @param filter
+     * @param options
+     */
+    function _searchContent(filter, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var expanded, apis, searchPromises, results;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expanded = expandContentFilter(filter);
+                        // APIs
+                        if (!options.apis) {
+                            // default to AGO PROD
+                            options.apis = ["arcgis"];
+                        }
+                        apis = expandApis(options.apis);
+                        searchPromises = apis.map(function (api) {
+                            var _a;
+                            // Portal Search
+                            if (api.type === "arcgis") {
+                                // serialize for portal
+                                var so = serializeContentFilterForPortal(expanded);
+                                // pass auth forward
+                                if (options.authentication) {
+                                    so.authentication = options.authentication;
+                                }
+                                // Aggregations
+                                if ((_a = options.aggregations) === null || _a === void 0 ? void 0 : _a.length) {
+                                    so.countFields = options.aggregations.join(",");
+                                    so.countSize = 200;
+                                }
+                                if (options.num) {
+                                    so.num = options.num;
+                                }
+                                return searchPortal(so);
+                            }
+                            else {
+                                // Hub API Search
+                                // TODO: Implement hub api content search
+                                return Promise.resolve({
+                                    content: [],
+                                    facets: [],
+                                });
+                            }
+                        });
+                        return [4 /*yield*/, Promise.all(searchPromises)];
+                    case 1:
+                        results = _a.sent();
+                        // merge and return
+                        return [2 /*return*/, mergeSearchResults(results)];
+                }
+            });
+        });
+    }
+    function searchPortal(searchOptions) {
+        return searchItems(searchOptions).then(function (resp) {
+            var content = resp.results.map(itemToContent);
+            // convert aggregations into facets
+            var facets = convertPortalResponseToFacets(resp);
+            return { content: content, facets: facets };
+        });
+    }
+
     /**
      * Parse a response object, and throw if it contains an error.
      * Just a wrapper to hide some platform idiosyncracies
@@ -9188,6 +10010,7 @@
     exports.PORTAL_EXPORT_TYPES = PORTAL_EXPORT_TYPES;
     exports.REQUIRED_PRIVS = REQUIRED_PRIVS;
     exports.RemoteServerError = RemoteServerError;
+    exports.SEARCH_APIS = SEARCH_APIS;
     exports.SITE_SCHEMA_VERSION = SITE_SCHEMA_VERSION;
     exports.STANDARD_LICENSES = STANDARD_LICENSES;
     exports.WGS84_WKID = WGS84_WKID;
@@ -9218,6 +10041,7 @@
     exports._processInvite = _processInvite;
     exports._processPrimaryEmail = _processPrimaryEmail;
     exports._processSecondaryEmail = _processSecondaryEmail;
+    exports._searchContent = _searchContent;
     exports._unprotectAndRemoveGroup = _unprotectAndRemoveGroup;
     exports._unprotectAndRemoveItem = _unprotectAndRemoveItem;
     exports.addContextToSlug = addContextToSlug;
@@ -9245,6 +10069,9 @@
     exports.cloneObject = cloneObject$1;
     exports.completeOAuth2 = completeOAuth2;
     exports.compose = compose;
+    exports.convertContentDefinitionToFilter = convertContentDefinitionToFilter;
+    exports.convertContentFilterToSearchOptions = convertContentFilterToSearchOptions;
+    exports.convertPortalResponseToFacets = convertPortalResponseToFacets;
     exports.convertSolutionTemplateResourcesToAssets = convertSolutionTemplateResourcesToAssets;
     exports.convertToWellKnownLocale = convertToWellKnownLocale;
     exports.createExtent = createExtent;
@@ -9262,6 +10089,9 @@
     exports.ensureProp = ensureProp;
     exports.ensureUniqueDomainName = ensureUniqueDomainName;
     exports.ensureUniqueString = ensureUniqueString;
+    exports.expandApis = expandApis;
+    exports.expandContentFilter = expandContentFilter;
+    exports.expandTypeField = expandTypeField;
     exports.extend = extend;
     exports.extentToBBox = extentToBBox;
     exports.failSafe = failSafe;
@@ -9349,7 +10179,12 @@
     exports.mapBy = mapBy;
     exports.maybeAdd = maybeAdd;
     exports.maybePush = maybePush;
+    exports.mergeContentFilter = mergeContentFilter;
+    exports.mergeDateRange = mergeDateRange;
+    exports.mergeMatchOptions = mergeMatchOptions;
     exports.mergeObjects = mergeObjects;
+    exports.mergeSearchOptions = mergeSearchOptions;
+    exports.mergeSearchResults = mergeSearchResults;
     exports.normalizeItemType = normalizeItemType;
     exports.normalizeSolutionTemplateItem = normalizeSolutionTemplateItem;
     exports.objectToArray = objectToArray;
@@ -9358,13 +10193,18 @@
     exports.parseItemCategories = parseItemCategories;
     exports.processRevertableTasks = processRevertableTasks;
     exports.propifyString = propifyString;
+    exports.relativeDateToDateRange = relativeDateToDateRange;
     exports.removeContextFromSlug = removeContextFromSlug;
     exports.removeDomain = removeDomain;
     exports.removeEmptyProps = removeEmptyProps;
     exports.replaceItemId = replaceItemId;
     exports.runRevertableTask = runRevertableTask;
+    exports.serializeContentFilterForPortal = serializeContentFilterForPortal;
+    exports.serializeDateRange = serializeDateRange;
+    exports.serializeMatchOptions = serializeMatchOptions;
     exports.serializeModel = serializeModel;
     exports.serializeSpatialReference = serializeSpatialReference;
+    exports.serializeStringOrArray = serializeStringOrArray;
     exports.setContentHubId = setContentHubId;
     exports.setContentSiteUrls = setContentSiteUrls;
     exports.setContentType = setContentType;
@@ -9380,6 +10220,7 @@
     exports.updateDomain = updateDomain;
     exports.upgradeSiteSchema = upgradeSiteSchema;
     exports.uploadResourcesFromUrl = uploadResourcesFromUrl;
+    exports.valueToMatchOptions = valueToMatchOptions;
     exports.without = without;
     exports.withoutByProp = withoutByProp;