@esri/hub-common 9.10.1 → 9.10.2

package/dist/types/search/types.d.ts

@@ -0,0 +1,315 @@
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { IHubContent, IModel } from "..";
+/**
+ * Generic filter used with various search functions.
+ *
+ * `Filter<T extends FilterType>` [FilterType](../FilterType) is constrained to
+ *
+ * - `Filter<"any">` [IAnyFilterDefinition](../IAnyFilterDefinition)
+ * - `Filter<"content">` [IContentFilterDefinition](../IContentFilterDefinition)
+ * - `Filter<"user">` [IUserFilterDefinition](../IUserFilterDefinition)
+ * - `Filter<"group">` [IGroupFilterDefinition](../IGroupFilterDefinition)
+ *
+ * When constructing a Filter as json, the `filterType` must be specified,
+ * and it must be `keyof` [FilterTypeMap](../FilterTypeMap)
+ *
+ * ```ts
+ * const f:Filter<"content"> = {
+ *   filterType: "content" // must match the FilterType
+ *   term: "water"
+ * }
+ * ```
+ */
+export declare type Filter<T extends FilterType> = IFilterTypeMap[T] & {
+    filterType: T;
+};
+/**
+ * Defines the valid FilterTypes for use with `Filter<T extends FilterType>`
+ * See [Filter](../Filter)
+ */
+export interface IFilterTypeMap {
+    any: IAnyFilterDefinition;
+    content: IContentFilterDefinition;
+    user: IUserFilterDefinition;
+    group: IGroupFilterDefinition;
+    event: IEventFilterDefinition;
+}
+export declare type FilterType = keyof IFilterTypeMap;
+/**
+ * Common set of fields that are reasonable to apply at the
+ * top level of a Catalog
+ */
+export interface IAnyFilterDefinition {
+    title?: string | string[] | IMatchOptions;
+    access?: string | string[] | IMatchOptions;
+    owner?: string | string[] | IMatchOptions;
+    tags?: string | string[] | IMatchOptions;
+    created?: IDateRange<number> | IRelativeDate;
+    modified?: IDateRange<number> | IRelativeDate;
+    description?: string | string[] | IMatchOptions;
+    group?: string | string[] | IMatchOptions;
+    orgid?: string | string[] | IMatchOptions;
+    type?: string | NamedContentFilter | Array<string | NamedContentFilter> | IMatchOptions;
+}
+/**
+ * Fields related to Content based searches
+ */
+export interface IContentFilterDefinition {
+    access?: string | string[] | IMatchOptions;
+    owner?: string | string[] | IMatchOptions;
+    tags?: string | string[] | IMatchOptions;
+    created?: IDateRange<number> | IRelativeDate;
+    description?: string | string[] | IMatchOptions;
+    snippet?: string | string[] | IMatchOptions;
+    group?: string | string[] | IMatchOptions;
+    id?: string | string[] | IMatchOptions;
+    modified?: IDateRange<number> | IRelativeDate;
+    orgid?: string | string[] | IMatchOptions;
+    term?: string;
+    title?: string | string[] | IMatchOptions;
+    type?: string | NamedContentFilter | Array<string | NamedContentFilter> | IMatchOptions;
+    typekeywords?: string | string[] | IMatchOptions;
+    [key: string]: any;
+    /**
+     * @internal
+     * Support for complex OR queries; Used with various expansions
+     */
+    subFilters?: Array<IContentFilterDefinition | NamedContentFilter>;
+}
+export interface IContentFilter {
+    access?: IMatchOptions;
+    created?: IDateRange<number>;
+    description?: IMatchOptions;
+    group?: IMatchOptions;
+    id?: IMatchOptions;
+    modified?: IDateRange<number>;
+    orgid?: IMatchOptions;
+    owner?: IMatchOptions;
+    tags?: IMatchOptions;
+    term?: string;
+    title?: IMatchOptions;
+    type?: IMatchOptions;
+    typekeywords?: IMatchOptions;
+    [key: string]: any;
+    subFilters?: IContentFilter[];
+}
+export interface IWellKnownContentFilters {
+    $apps: IContentFilterDefinition[];
+    $dashboard: IContentFilterDefinition[];
+    $dataset: IContentFilterDefinition[];
+    $experience: IContentFilterDefinition[];
+    $site: IContentFilterDefinition[];
+    $storymap: IContentFilterDefinition[];
+    $initiative: IContentFilterDefinition[];
+    $document: IContentFilterDefinition[];
+}
+export declare type NamedContentFilter = keyof IWellKnownContentFilters;
+export interface IUserFilterDefinition {
+    created?: IDateRange<number> | IRelativeDate;
+    disabled?: boolean;
+    email?: string | string[] | IMatchOptions;
+    firstname?: string | string[] | IMatchOptions;
+    fullname?: string | string[] | IMatchOptions;
+    groups?: string | string[] | IMatchOptions;
+    lastlogin?: IDateRange<number> | IRelativeDate;
+    lastname?: string | string[] | IMatchOptions;
+    modified?: IDateRange<number> | IRelativeDate;
+    role?: string | string[] | IMatchOptions;
+    term?: string;
+    userlicensetype?: string | string[] | IMatchOptions;
+    username?: string | string[] | IMatchOptions;
+}
+export interface IGroupFilterDefinition {
+    access?: string | string[] | IMatchOptions;
+    created?: IDateRange<number> | IRelativeDate;
+    id?: string | string[] | IMatchOptions;
+    isInvitationOnly?: boolean;
+    modified?: IDateRange<number> | IRelativeDate;
+    orgid?: string | string[] | IMatchOptions;
+    owner?: string | string[] | IMatchOptions;
+    searchUserAccess?: "groupMember";
+    tags?: string | string[] | IMatchOptions;
+    term?: string;
+    title?: string | string[] | IMatchOptions;
+    typekeywords?: string | string[] | IMatchOptions;
+}
+export interface IEventFilterDefinition {
+    created?: IDateRange<number> | IRelativeDate;
+    modified?: IDateRange<number> | IRelativeDate;
+    orgid?: string | string[] | IMatchOptions;
+    title?: string | string[] | IMatchOptions;
+}
+export interface IFacet {
+    label: string;
+    attribute?: string;
+    type: "single-select" | "multi-select" | "date-range" | "histogram";
+    options?: IFacetOption[];
+}
+export interface IFacetOption {
+    label: string;
+    value: string;
+    count?: number;
+    selected: boolean;
+    filter: Filter<FilterType>;
+}
+/**
+ * Catalog is the definition which powers what options
+ * are available in a Gallery. It controls not only
+ * the scoping of the search, but also the options
+ * available to the UX.
+ *
+ * Thus the lower-level `searchContent`, `searchUser`, `searchGroup` functions
+ * do not take Catalogs, rather they accept [Filters](../Filter)
+ *
+ * ```ts
+ * const simpleCatalog:Catalog = {
+ *   title: "Select Map",
+ *   filter: {
+ *     filterType: "content",
+ *     type: "Web Map",
+ *     owner: "jsmith"
+ *   }
+ * }
+ * ```
+ *
+ * ## Collections
+ * The key feature of a Catalog is the ability to defined [Collections](../Collection).
+ * These are essentially sub-sets of content, typically organized around
+ * generalized content types, i.e. "Datasets", vs "Maps", vs "Documents"
+ *
+ *
+ * ```ts
+ * const complex:Catalog = {
+ *   filter: {
+ *    type: "content",
+ *    groups: ["3ef", "bc4"]
+ *   },
+ *   collections: [
+ *     {
+ *       label: "Documents",
+ *       filter: {
+ *         filterType: "content",
+ *         type: ["Microsoft Word", "PDF", "Microsoft Excel"]
+ *       }
+ *     },
+ *     {
+ *       label: "Datasets",
+ *       filter: {
+ *         filterType: "content",
+ *         type: ["Feature Layer", "Feature Service", "Map Service", "CSV"]
+ *       }
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export interface ICatalog {
+    /**
+     * Title for the Gallery
+     */
+    title?: string;
+    filter: Filter<FilterType>;
+    sort?: ISortOption[];
+    collections?: ICollection[];
+    facets?: IFacet[];
+}
+/**
+ * Sort Option to be displayed in a UI
+ */
+export interface ISortOption {
+    label: string;
+    attribute: string;
+}
+/**
+ * A Filter that defines a subset of a Catalog, aka a Collection
+ */
+export interface ICollection {
+    label: string;
+    filter: Filter<FilterType>;
+    facets?: IFacet[];
+}
+/**
+ * Defines a span of time by specifying a `from` and `to` Date
+ * as either a number or a ISO string
+ */
+export interface IDateRange<T> {
+    type?: "date-range";
+    from: T;
+    to: T;
+}
+/**
+ * Relative Date will be convertd to a `IDateRange` at run-time
+ */
+export interface IRelativeDate {
+    type: "relative-date";
+    num: number;
+    unit: "minutes" | "hours" | "days" | "weeks" | "months" | "years";
+}
+/**
+ * Define how values should be matched
+ */
+export interface IMatchOptions {
+    /**
+     * return results which have ANY of the listed values
+     * for the specified field
+     */
+    any?: string | string[];
+    /**
+     * return resutls which have ALL of the listed values
+     * for the specified field
+     */
+    all?: string | string[];
+    /**
+     * return results which do not have any of the listed
+     * values for the specified field
+     */
+    not?: string | string[];
+    /**
+     * Depending on the API being searched, `exact` will
+     * attempt to structure the query such that it is an
+     * exact match. For Portal API, this may involve using
+     * the `filter` parameter, if the specific field can
+     * be used with that parameter
+     */
+    exact?: string | string[];
+}
+/**
+ * Search Options
+ */
+export interface IHubSearchOptions {
+    site?: IModel;
+    authentication?: UserSession;
+    sortField?: string;
+    sortOrder?: "desc" | "asc";
+    page?: string;
+    num?: number;
+    aggregations?: string[];
+    bbox?: string;
+    fields?: string;
+    api?: NamedApis | IApiDefinition;
+}
+/**
+ * searchContent return
+ */
+export interface IContentSearchResult {
+    total: number;
+    results: IHubContent[];
+    facets?: IFacet[];
+    hasNext: boolean;
+    next: (params?: any) => Promise<IContentSearchResult>;
+}
+export interface IWellKnownApis {
+    arcgis: IApiDefinition;
+    arcgisQA: IApiDefinition;
+    arcgisDEV: IApiDefinition;
+    hub: IApiDefinition;
+    hubQA: IApiDefinition;
+    hubDEV: IApiDefinition;
+}
+export declare type NamedApis = keyof IWellKnownApis;
+export interface IApiDefinition {
+    label?: string;
+    url: string;
+    type: "arcgis" | "arcgis-hub";
+    authentication?: UserSession;
+}

package/dist/types/search/user-utils.d.ts

@@ -0,0 +1,35 @@
+import { ISearchOptions } from "@esri/arcgis-rest-portal";
+import { Filter, IUserFilterDefinition } from "..";
+/**
+ *
+ * Merge `Filter<"user">` objects
+ *
+ * Useful in components which may get partial filters from a variety of
+ * sub-components, which are then combined into a single filter prior
+ * to executing the search.
+ * @param filters
+ * @returns
+ */
+export declare function mergeUserFilters(filters: Array<Filter<"user">>): Filter<"user">;
+/**
+ * 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 structures
+ * we expand them into their more verbose form.
+ *
+ * i.e. `firstname: "John"` expands into `firstname: { any: ["John"]}`
+ *
+ * - Fields defined as `string | string[] | MatchOptions` will be converted to a `MatchOptions`
+ * - RelativeDate fields are converted to DateRange<number>
+ * @param filter
+ * @returns
+ */
+export declare function expandUserFilter(filter: Filter<"user">): IUserFilterDefinition;
+/**
+ * @private
+ * Serialize an `IUserFilterDefinition` into an `ISearchOptions` for use
+ * with `searchUsers`
+ * @param filter
+ * @returns
+ */
+export declare function serializeUserFilterForPortal(filter: IUserFilterDefinition): ISearchOptions;

package/dist/types/search/utils.d.ts

@@ -0,0 +1,124 @@
+import { IUser } from "@esri/arcgis-rest-auth";
+import { IGroup, ISearchOptions } from "@esri/arcgis-rest-portal";
+import { ISearchResponse } from "..";
+import { IMatchOptions, IDateRange, IRelativeDate, IWellKnownApis, IApiDefinition, NamedApis } from "./types";
+/**
+ * Well known APIs
+ * Short-forms for specifying common APIs
+ * We will likely deprecate this
+ */
+export declare const SEARCH_APIS: IWellKnownApis;
+/**
+ * @private
+ * Convert array of api "names" into full ApiDefinitions
+ * @param apis
+ * @returns
+ */
+export declare function expandApis(apis: Array<NamedApis | IApiDefinition>): IApiDefinition[];
+/**
+ * @private
+ * Convert an api "name" into a full ApiDefinition
+ * @param api
+ * @returns
+ */
+export declare function expandApi(api: NamedApis | IApiDefinition): IApiDefinition;
+/**
+ * @private
+ * Merge two date ranges by taking the longest span
+ * @param dr1
+ * @param dr2
+ * @returns
+ */
+export declare function mergeDateRange(dr1: IDateRange<number>, dr2: IDateRange<number>): IDateRange<number>;
+/**
+ * @private
+ * Merge two [`MatchOptions`](../MatchOptions)
+ *
+ * Currently a naieve implementation where the arrays are simply merged
+ *
+ * @param mo1
+ * @param mo2
+ * @returns
+ */
+export declare function mergeMatchOptions(mo1: IMatchOptions, mo2: IMatchOptions): IMatchOptions;
+/**
+ * @private
+ * Convert a field value into a MatchOptions if it's not already one
+ * @param value
+ * @returns
+ */
+export declare function valueToMatchOptions(value: string | string[] | IMatchOptions): IMatchOptions;
+/**
+ * @private
+ * Convert a RelativeDate to a DateRange<number>
+ * @param relative
+ * @returns
+ */
+export declare function relativeDateToDateRange(relative: IRelativeDate): IDateRange<number>;
+/**
+ * @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
+ */
+export declare function mergeSearchOptions(so1: ISearchOptions, so2: ISearchOptions, join: "AND" | "OR"): ISearchOptions;
+/**
+ * @private
+ * Serialize a `MatchOptions` into `q` or `filter` on an `ISearchOptions`
+ * @param key
+ * @param opts
+ * @returns
+ */
+export declare function serializeMatchOptions(key: string, opts: IMatchOptions): ISearchOptions;
+/**
+ * @private
+ * Serialize a DateRange<number> into a Portal Query string
+ * @param key
+ * @param range
+ * @returns
+ */
+export declare function serializeDateRange(key: string, range: IDateRange<number>): ISearchOptions;
+/**
+ * @private
+ * Serialize a `string` or `string[]` into a string
+ * @param join
+ * @param key
+ * @param value
+ * @returns
+ */
+export declare function serializeStringOrArray(join: "AND" | "OR", key: string, value: string | string[]): string;
+/**
+ * Create a `.next()` function for a type
+ * @param request
+ * @param nextStart
+ * @param total
+ * @param fn
+ * @returns
+ */
+export declare function getNextFunction<T>(request: ISearchOptions, nextStart: number, total: number, fn: (r: any) => Promise<ISearchResponse<T>>): () => Promise<ISearchResponse<T>>;
+/**
+ * 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
+ * @param portalUrl
+ * @param group
+ * @param token
+ * @returns
+ */
+export declare function getGroupThumbnailUrl(portalUrl: string, group: IGroup, token?: string): string;
+/**
+ * Construct a the full url to a user thumbnail
+ *
+ * - If the user has a thumbnail, construct the full url
+ * - If the user is not public, append on the token
+ * @param portalUrl
+ * @param user
+ * @param token
+ * @returns
+ */
+export declare function getUserThumbnailUrl(portalUrl: string, user: IUser, token?: string): string;

package/dist/types/sites/_apply-site-schema.d.ts

@@ -0,0 +1,7 @@
+import { IModel } from "../types";
+/**
+ * Apply the first schema version to the item
+ * @param {Object} model Site Model
+ * @private
+ */
+export declare function _applySiteSchema(model: IModel): IModel;

package/dist/types/sites/_enforce-lowercase-domains.d.ts

@@ -0,0 +1,7 @@
+import { IModel } from "..";
+/**
+ * Enforce lowercase domains
+ * @param {Object} model Site Model
+ * @private
+ */
+export declare function _enforceLowercaseDomains(model: IModel): IModel;

package/dist/types/sites/_ensure-catalog.d.ts

@@ -0,0 +1,8 @@
+import { IModel } from "..";
+/**
+ * Move the data.values.groups array into the
+ * data.catalog object
+ * @param {Object} model Site Model
+ * @private
+ */
+export declare function _ensureCatalog(model: IModel): IModel;

package/dist/types/sites/_ensure-telemetry.d.ts

@@ -0,0 +1,8 @@
+import { IModel, IDraft } from "..";
+/**
+ * Add telemetry config object
+ * @private
+ * @param {object} model Site Model
+ * @returns {object}
+ */
+export declare function _ensureTelemetry<T extends IModel | IDraft>(model: T): T;

package/dist/types/sites/_migrate-feed-config.d.ts

@@ -0,0 +1,15 @@
+import { IModel } from "..";
+/**
+ * Migrates the site so it can store configurations for multiple feed formats
+ * (dcat-us-1.1, dcat-ap-2.0.1, etc.). If the site has an existing custom
+ * configuration for dcat-us 1.1, a copy of that configuration will be modified
+ * to use values from the v3 api instead of values from the index.
+ *
+ * Structural Impacts:
+ * - site.data.feeds will be added.
+ * - site.data.feeds.dcatUS11 will be added if site.data.values.dcatConfig exists.
+ *
+ * @param {object} model Site Model
+ * @private
+ */
+export declare function _migrateFeedConfig(model: IModel): IModel;

package/dist/types/sites/_purge-non-guids-from-catalog.d.ts

@@ -0,0 +1,7 @@
+import { IModel } from "..";
+/**
+ * Remove any non-guid entries from the data catalog groups array
+ * @param {object} model Site Model
+ * @private
+ */
+export declare function _purgeNonGuidsFromCatalog(model: IModel): IModel;

package/dist/types/sites/domains/_check-status-and-parse-json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse a response object, and throw if it contains an error.
+ * Just a wrapper to hide some platform idiosyncracies
+ * @param {Response} response Response object to parse
+ * @private
+ */
+export declare function _checkStatusAndParseJson(response: Response): Promise<any>;

package/dist/types/sites/domains/_ensure-safe-domain-length.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ensure that a subdomain is not greater than 63 characters in length
+ * Subdomains are prep-ended on the org's url key, and the combined
+ * length can not exceed 63 chars as per rules of domains.
+ * If the requested subdomain + the url key is > 63 chars, we
+ * strip off the last 6 chars and replace that w/ random characeters
+ * This was an actual reported bug.
+ * @param {String} subdomain Proposed subdomain
+ * @param {String} urlKey Org url key
+ * @private
+ */
+export declare function _ensureSafeDomainLength(subdomain: string, urlKey?: string): string;

package/dist/types/sites/domains/_get-auth-header.d.ts

@@ -0,0 +1,12 @@
+import { IHubRequestOptions } from "../../types";
+interface IHeaders {
+    Authorization?: string;
+    [key: string]: string;
+}
+/**
+ * Construct the auth header from a hub request options
+ * @param {IHubRequestOptions} hubRequestOptions
+ * @private
+ */
+export declare function _getAuthHeader(hubRequestOptions: IHubRequestOptions): IHeaders;
+export {};

package/dist/types/sites/domains/_get-domain-service-url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extract the domain service from the request options
+ * @param {string} hubApiUrl
+ * @private
+ */
+export declare function _getDomainServiceUrl(hubApiUrl?: string): string;

package/dist/types/sites/domains/_lookup-portal.d.ts

@@ -0,0 +1,11 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+/**
+ * Lookup a domain in Portal
+ * @param {string} hostname to locate the site for
+ * @param {IRequestOptions} requestOptions
+ * @private
+ */
+export declare function _lookupPortal(hostname: string, requestOptions: IRequestOptions): Promise<{
+    hostname: string;
+    siteId: string;
+}>;

package/dist/types/sites/domains/add-domain.d.ts

@@ -0,0 +1,7 @@
+import { IDomainEntry, IHubRequestOptions } from "../../types";
+/**
+ * Create an entry in the domain system
+ * @param {IHubDomain} domainEntry Domain hash to be stored
+ * @param {IHubRequestOptions} hubRequestOptions
+ */
+export declare function addDomain(domainEntry: Partial<IDomainEntry>, hubRequestOptions: IHubRequestOptions): Promise<any>;

package/dist/types/sites/domains/domain-exists-portal.d.ts

@@ -0,0 +1,7 @@
+import { IHubRequestOptions } from "../../types";
+/**
+ * Check if an item exists with the specified domain keyword
+ * @param {String} hostname to check for
+ * @param {IHubRequestOptions} hubRequestOptions
+ */
+export declare function domainExistsPortal(hostname: string, hubRequestOptions: IHubRequestOptions): Promise<boolean>;

package/dist/types/sites/domains/domain-exists.d.ts

@@ -0,0 +1,11 @@
+import { IHubRequestOptions } from "../../types";
+/**
+ * Check if a domain entry exists. Different from lookupDomain
+ * in that this will return true/false, where as lookupDomain will
+ * return the domain entry or throw. However, lookupDomain can work
+ * with ArcGIS Enterprise.
+ * Will throw if used in Portal.
+ * @param {string} hostname Domain entry to check for
+ * @param {IHubRequestOptions} hubRequestOptions
+ */
+export declare function domainExists(hostname: string, hubRequestOptions: IHubRequestOptions): Promise<boolean>;

package/dist/types/sites/domains/ensure-unique-domain-name.d.ts

@@ -0,0 +1,8 @@
+import { IHubRequestOptions } from "../../types";
+/**
+ * Given a subdomain, ensure that we have a unique hostname
+ * incrementing if needed
+ * @param {String} subdomain Subdomain to unique-ify
+ * @param {IHubRequestOptions} hubRequestOptions
+ */
+export declare function ensureUniqueDomainName(subdomain: string, hubRequestOptions: IHubRequestOptions): Promise<string>;

package/dist/types/sites/domains/get-domains-for-site.d.ts

@@ -0,0 +1,7 @@
+import { IHubRequestOptions, IDomainEntry } from "../../types";
+/**
+ * Get a list
+ * @param {string} siteId Item id of the Site
+ * @param {IHubRequestOptions} hubRequestOptions
+ */
+export declare function getDomainsForSite(siteId: string, hubRequestOptions: IHubRequestOptions): Promise<IDomainEntry[]>;

package/dist/types/sites/domains/get-unique-domain-name-portal.d.ts

@@ -0,0 +1,9 @@
+import { IHubRequestOptions } from "../../types";
+/**
+ * Ensure a unique domain name by checking for and incrementing
+ * a subdomain
+ * @param {String} subdomain Subdomain to ensure is unique
+ * @param {IHubRequestOptions} hubRequestOptions
+ * @param {*} step Step number
+ */
+export declare function getUniqueDomainNamePortal(subdomain: string, hubRequestOptions: IHubRequestOptions, step?: number): Promise<string>;

package/dist/types/sites/domains/get-unique-domain-name.d.ts

@@ -0,0 +1,10 @@
+import { IHubRequestOptions } from "../../types";
+/**
+ * Ensure a unique domain name by checking for and incrementing
+ * a subdomain
+ * @param {String} subdomain Subdomain to ensure is unique
+ * @param {String} baseHostname base hostname
+ * @param hubRequestOptions
+ * @param {Number} step Step number
+ */
+export declare function getUniqueDomainName(subdomain: string, baseHostname: string, hubRequestOptions: IHubRequestOptions, step?: number): Promise<string>;

package/dist/types/sites/domains/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./_check-status-and-parse-json";
+export * from "./_get-auth-header";
+export * from "./_get-domain-service-url";
+export * from "./_lookup-portal";
+export * from "./add-domain";
+export * from "./domain-exists";
+export * from "./domain-exists-portal";
+export * from "./get-domains-for-site";
+export * from "./get-unique-domain-name";
+export * from "./get-unique-domain-name-portal";
+export * from "./is-domain-for-legacy-site";
+export * from "./is-domain-used-elsewhere";
+export * from "./is-valid-domain";
+export * from "./lookup-domain";
+export * from "./remove-domain";
+export * from "./update-domain";
+export * from "./_ensure-safe-domain-length";
+export * from "./ensure-unique-domain-name";