@esri/hub-common 13.17.2 → 13.17.4

package/dist/types/initiatives/view.d.ts

@@ -0,0 +1,19 @@
+import { IHubInitiative } from "../core";
+import { EntityToCardModelFn, ResultToCardModelFn } from "../core/types/IHubCardViewModel";
+/**
+ * Convert an initiative entity in a card view model
+ * that can be consumed by the suite of hub gallery components
+ *
+ * @param initiative initiative entity
+ * @param context auth & portal information
+ * @param opts view model options
+ */
+export declare const initiativeToCardModel: EntityToCardModelFn<IHubInitiative>;
+/**
+ * Conver an initiative search result into a card view model
+ * that can be consumed by the suite of hub gallery components
+ *
+ * @param searchResult hub initiative search result
+ * @param opts view model options
+ */
+export declare const initiativeResultToCardModel: ResultToCardModelFn;

package/dist/types/items/deleteItemThumbnail.d.ts

@@ -0,0 +1,9 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Delete an item's thumbnail
+ * @param id
+ * @param owner
+ * @param requestOptions
+ * @returns
+ */
+export declare function deleteItemThumbnail(id: string, owner: string, requestOptions: IUserRequestOptions): Promise<any>;

package/dist/types/pages/HubPage.d.ts

@@ -0,0 +1,71 @@
+import { IHubPage, IWithStoreBehavior, IWithSharingBehavior, IHubPageEditor, IEntityEditorContext } from "../core";
+import { IArcGISContext } from "../ArcGISContext";
+import { HubItemEntity } from "../core/HubItemEntity";
+import { IEditorConfig, IWithEditorBehavior } from "../core/behaviors/IWithEditorBehavior";
+import { PageEditorType } from "./_internal/PageSchema";
+/**
+ * Hub Page Class
+ * NOTE: This is a minimal implementation.
+ */
+export declare class HubPage extends HubItemEntity<IHubPage> implements IWithStoreBehavior<IHubPage>, IWithSharingBehavior, IWithEditorBehavior {
+    /**
+     * Private constructor so we don't have `new` all over the place. Allows for
+     * more flexibility in how we create the HubPageManager over time.
+     * @param context
+     */
+    private constructor();
+    /**
+     * Create an instance from an IHubPage object
+     * @param json - JSON object to create a HubPage from
+     * @param context - ArcGIS context
+     * @returns
+     */
+    static fromJson(json: Partial<IHubPage>, context: IArcGISContext): HubPage;
+    /**
+     *
+     * Create a new HubPage, returning a HubPage instance.
+     * By default, this does not save the page to the backing store.
+     * @param partialPage
+     * @param context
+     * @returns
+     */
+    static create(partialPage: Partial<IHubPage>, context: IArcGISContext, save?: boolean): Promise<HubPage>;
+    /**
+     * Fetch a Page from the backing store and return a HubPage instance.
+     * @param identifier - Identifier of the page to load
+     * @param context
+     * @returns
+     */
+    static fetch(identifier: string, context: IArcGISContext): Promise<HubPage>;
+    private static applyDefaults;
+    /**
+     * Apply a new state to the instance
+     * @param changes
+     */
+    update(changes: Partial<IHubPage>): void;
+    /**
+     * Save the HubPage to the backing store.
+     * Currently Pages are stored as Items in Portal
+     * @returns
+     */
+    save(): Promise<void>;
+    /**
+     * Delete the HubPage from the store
+     * set a flag to indicate that it is destroyed
+     * @returns
+     */
+    delete(): Promise<void>;
+    getEditorConfig(i18nScope: string, type: PageEditorType): Promise<IEditorConfig>;
+    /**
+     * Return the project as an editor object
+     * @param editorContext
+     * @returns
+     */
+    toEditor(editorContext?: IEntityEditorContext, include?: string[]): Promise<IHubPageEditor>;
+    /**
+     * Load the project from the editor object
+     * @param editor
+     * @returns
+     */
+    fromEditor(editor: IHubPageEditor): Promise<IHubPage>;
+}

package/dist/types/pages/_internal/PageSchema.d.ts

@@ -0,0 +1,7 @@
+import { IConfigurationSchema } from "../../core";
+export declare const PageEditorTypes: readonly ["hub:page:edit"];
+export declare type PageEditorType = (typeof PageEditorTypes)[number];
+/**
+ * defines the JSON schema for a Hub Site's editable fields
+ */
+export declare const PageSchema: IConfigurationSchema;

package/dist/types/pages/_internal/PageUiSchemaEdit.d.ts

@@ -0,0 +1,10 @@
+import { IUiSchema } from "../../core/schemas/types";
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubPage } from "../../core/types";
+/**
+ * @private
+ * constructs the complete edit uiSchema for Hub Pages.
+ * This defines how the schema properties should be
+ * rendered in the page editing experience
+ */
+export declare const buildUiSchema: (i18nScope: string, entity: IHubPage, context: IArcGISContext) => Promise<IUiSchema>;

package/dist/types/pages/_internal/computeProps.d.ts

@@ -0,0 +1,12 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { IModel } from "../../types";
+import { IHubPage } from "../../core/types/IHubPage";
+/**
+ * Given a model and a page, set various computed properties that can't be directly mapped
+ * @private
+ * @param model
+ * @param page
+ * @param requestOptions
+ * @returns
+ */
+export declare function computeProps(model: IModel, page: Partial<IHubPage>, requestOptions: IRequestOptions): IHubPage;

package/dist/types/pages/_internal/getPropertyMap.d.ts

@@ -0,0 +1,8 @@
+import { IPropertyMap } from "../../core/_internal/PropertyMapper";
+/**
+ * Returns an Array of IPropertyMap objects
+ * that define the projection of properties from a IModel to an IHubPage
+ * @returns
+ * @private
+ */
+export declare function getPropertyMap(): IPropertyMap[];

package/dist/types/pages/defaults.d.ts

@@ -0,0 +1,13 @@
+import { IHubPage } from "../core";
+import { IModel } from "../types";
+export declare const HUB_PAGE_ITEM_TYPE = "Hub Page";
+export declare const ENTERPRISE_PAGE_ITEM_TYPE = "Site Page";
+export declare const PAGE_TYPE_KEYWORD = "hubPage";
+/**
+ * Default values of a IHubPage
+ */
+export declare const DEFAULT_PAGE: Partial<IHubPage>;
+/**
+ * Default values for a new HubPage Model
+ */
+export declare const DEFAULT_PAGE_MODEL: IModel;

package/dist/types/permissions/PlatformPermissionPolicies.d.ts

@@ -0,0 +1,9 @@
+import { IPermissionPolicy } from "./types/IPermissionPolicy";
+/**
+ * All the permission policies for the Hub
+ */
+export declare const PlatformPermissions: string[];
+/**
+ * Platform Permission policies which delegate to Platform Privileges
+ */
+export declare const PlatformPermissionPolicies: IPermissionPolicy[];

package/dist/types/permissions/_internal/PermissionCheckFunction.d.ts

@@ -0,0 +1,7 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+/**
+ * Type signature for Permission Check Functions
+ */
+export declare type PermissionCheckFunction = (policy: IPermissionPolicy, context: IArcGISContext, entity?: Record<string, any>) => IPolicyCheck[];

package/dist/types/permissions/_internal/checkAvailability.d.ts

@@ -0,0 +1,13 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+/**
+ * @internal
+ * Verify that the policy.availability requirement is met.
+ * If a value is specified in the policy, the current context must be one of those values.
+ * @param policy
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkAvailability(policy: IPermissionPolicy, context: IArcGISContext, _entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/checkEntityFeature.d.ts

@@ -0,0 +1,4 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+export declare function checkEntityFeature(policy: IPermissionPolicy, _entitycontext: IArcGISContext, entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/checkEnvironment.d.ts

@@ -0,0 +1,13 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+/**
+ * @internal
+ * Verify that the policy.environment requirement is met.
+ *
+ * @param policy
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkEnvironment(policy: IPermissionPolicy, context: IArcGISContext, _entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/checkFeature.d.ts

@@ -0,0 +1,16 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy, IPolicyCheck } from "../types";
+declare const validFeatures: string[];
+export declare type HubFeature = (typeof validFeatures)[number];
+export declare type HubFeatures = {
+    [key in HubFeature]: boolean;
+};
+/**
+ * Validate entityOwner policy
+ * @param policy
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkFeatures(policy: IPermissionPolicy, context: IArcGISContext, entity?: Record<string, any>): IPolicyCheck[];
+export {};

package/dist/types/permissions/_internal/checkFeatures.d.ts

@@ -0,0 +1,10 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy, IPolicyCheck } from "../types";
+/**
+ * Validate entityOwner policy
+ * @param policy
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkFeature(policy: IPermissionPolicy, context: IArcGISContext, entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/checkParents.d.ts

@@ -0,0 +1,12 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+/**
+ * @internal
+ * Check the parent policies for the given policy
+ * @param policy
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkParents(policy: IPermissionPolicy, context: IArcGISContext, entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/checkServiceStatus.d.ts

@@ -0,0 +1,4 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IPermissionPolicy } from "../types/IPermissionPolicy";
+import { IPolicyCheck } from "../types/IPolicyCheck";
+export declare function checkServiceStatus(policy: IPermissionPolicy, context: IArcGISContext, _entity?: Record<string, any>): IPolicyCheck[];

package/dist/types/permissions/_internal/processEntityFeatures.d.ts

@@ -0,0 +1,9 @@
+import { IFeatureFlags } from "../types/IPermissionPolicy";
+/**
+ * Take an entity's features and merge them with the default features ensuring
+ * that only the featires defined in the business rules are allowed through.
+ * @param entityFeatures
+ * @param defaultFeatures
+ * @returns
+ */
+export declare function processEntityFeatures(entityFeatures: IFeatureFlags, defaultFeatures: IFeatureFlags): IFeatureFlags;

package/dist/types/projects/_internal/getProjectEditorConfigOptions.d.ts

@@ -0,0 +1,10 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { UiSchemaElementOptions } from "../../core/schemas/types";
+import { IHubProject } from "../../core/types/IHubProject";
+/**
+ * Construct the Project Editor configuration options
+ * @param entity
+ * @param context
+ * @returns
+ */
+export declare function getProjectEditorConfigOptions(entity: IHubProject, context: IArcGISContext): Promise<UiSchemaElementOptions[]>;

package/dist/types/search/_internal/commonHelpers/getDiscussionsApiDefinition.d.ts

@@ -0,0 +1,2 @@
+import { IApiDefinition } from "../../types/types";
+export declare function getDiscussionsApiDefinition(): IApiDefinition;

package/dist/types/search/_internal/commonHelpers/shouldUseDiscussionsApi.d.ts

@@ -0,0 +1,11 @@
+import { EntityType } from "../../types/IHubCatalog";
+import { IHubSearchOptions } from "../../types/IHubSearchOptions";
+/**
+ * @private
+ * Determines if the Discussions API can be targeted with the given
+ * search parameters
+ * @param targetEntity
+ * @param options
+ * @returns boolean
+ */
+export declare function shouldUseDiscussionsApi(targetEntity: EntityType, options: IHubSearchOptions): boolean;

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

@@ -0,0 +1,11 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { GenericResult, IFilterExplanation } from "../explainQueryResult";
+import { IFilter } from "../types/IHubCatalog";
+/**
+ * Generate an explanation if a specific result passes the filter's criteria
+ * @param filter
+ * @param result
+ * @param requestOptions
+ * @returns
+ */
+export declare function explainFilter(filter: IFilter, result: GenericResult, requestOptions: IRequestOptions): Promise<IFilterExplanation>;

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

@@ -0,0 +1,38 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { GenericResult, IMatchReason, IPredicateExplanation } from "../explainQueryResult";
+import { IMatchOptions } from "../types";
+export declare function explainDatePredicate(predicate: Record<string, IMatchOptions>, result: GenericResult, requestOptions: IRequestOptions): Promise<IPredicateExplanation>;
+export declare function explainPropPredicate(predicate: Record<string, IMatchOptions>, result: GenericResult, requestOptions: IRequestOptions): Promise<IPredicateExplanation>;
+/**
+ * @internal
+ * Create explanation for an IMatchOptions predicate
+ * @param predicate
+ * @param result
+ * @param requestOptions
+ * @returns
+ */
+export declare function explainMatchOptionPredicate(predicate: Record<string, IMatchOptions>, result: GenericResult, requestOptions: IRequestOptions): Promise<IPredicateExplanation>;
+/**
+ * Returns information about the match between a result value and the .any property of an IMatchOptions predicate
+ * @param attribute
+ * @param option
+ * @param resultValue
+ * @returns
+ */
+export declare function checkAny(attribute: string, option: string | string[], resultValue: string | string[]): IMatchReason;
+/**
+ * * Returns information about the match between a result value and the .all property of an IMatchOptions predicate
+ * @param attribute
+ * @param option
+ * @param resultValue
+ * @returns
+ */
+export declare function checkAll(attribute: string, option: string | string[], resultValue: string | string[]): IMatchReason;
+/**
+ * * Returns information about the match between a result value and the .not property of an IMatchOptions predicate
+ * @param attribute
+ * @param option
+ * @param resultValue
+ * @returns
+ */
+export declare function checkNot(attribute: string, option: string | string[], resultValue: string | string[]): IMatchReason;

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

@@ -0,0 +1,12 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { GenericResult, IPredicateExplanation } from "../explainQueryResult";
+import { IMatchOptions } from "../types";
+/**
+ * Geneate an explanation if a specific result passes the predicate's criteria
+ * This will delegate to more specific functions based on the predicate's key
+ * @param predicate
+ * @param result
+ * @param requestOptions
+ * @returns
+ */
+export declare function explainPredicate(predicate: Record<string, IMatchOptions>, result: GenericResult, requestOptions: IRequestOptions): Promise<IPredicateExplanation>;

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

@@ -0,0 +1,9 @@
+import { EntityType } from "../types";
+/**
+ * @private
+ * Given a type (e.g. Hub Site Application) return the appropriate entity type
+ * that can be used as a `targetEntity` in an `IQuery`
+ * @param type
+ * @returns
+ */
+export declare function getEntityTypeFromType(type: string): EntityType;

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

@@ -0,0 +1,30 @@
+import { IHubSearchOptions, IHubSearchResponse, IHubSearchResult, IQuery } from "../types";
+import { IChannel, IPagedResponse, ISearchChannelsParams } from "../../discussions";
+/**
+ * @private
+ * Convert hubSearch IHubSearchOptions and IQuery interfaces to a
+ * ISearchChannelsParams structure that is needed for the Discussions API
+ * searchChannels(searchOptions: ISearchCHannelsParams) function
+ * @param {IHubSearchOptions} options
+ * @param {IQuery} query
+ * @returns ISearchChannelParams
+ */
+export declare const processSearchParams: (options: IHubSearchOptions, query: IQuery) => ISearchChannelsParams;
+/**
+ * @private
+ * Convert the Discussions API searchChannels response into an
+ * IHubSearchResponse necessary for supporting hubSearch results
+ * @param {IPagedResponse{IChannel}} channelsResponse
+ * @param {IQuery} query
+ * @param {IHubSearchOptions} options
+ * @returns IHubSearchResponse<IHubSearchResult>
+ */
+export declare const toHubSearchResult: (channelsResponse: IPagedResponse<IChannel>, query: IQuery, options: IHubSearchOptions) => Promise<IHubSearchResponse<IHubSearchResult>>;
+/**
+ * @private
+ * Execute channel search against the Discussions API
+ * @param query
+ * @param options
+ * @returns
+ */
+export declare const hubSearchChannels: (query: IQuery, options: IHubSearchOptions) => Promise<IHubSearchResponse<IHubSearchResult>>;

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

@@ -0,0 +1,9 @@
+import { IQuery } from "../types/IHubCatalog";
+/**
+ * @private
+ * Helper function that locates group predicates and "negates" them
+ * so we get a query that is `not in groups ...` vs `in groups ...`
+ * @param query
+ * @returns
+ */
+export declare function negateGroupPredicates(query: IQuery): IQuery;

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

@@ -1,7 +1,8 @@
 import { IHubSearchOptions, IHubSearchResponse, IHubSearchResult, IQuery } from "../types";
 /**
  * Search for members of a group.
- * The group is specified via `IQuery.properties.groupId`
+ * The groupId is specified via a `group` predicate.
+ * Any `term` predicate will be re-mapped to `name`.
  *
  * The backing API is very limited in what
  * it returns so this method executes the search and then tries to fetch

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

@@ -0,0 +1,102 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { IFilter, IPredicate, IQuery } from "./types";
+/**
+ * Explanation of why a result matched a query
+ */
+export interface IQueryExplanation {
+    /**
+     * Copy of result; Useful when doing bulk calls
+     */
+    result: GenericResult;
+    /**
+     * Copy of query; Useful when doing bulk calls
+     */
+    query: IQuery;
+    /**
+     * Whether the result matched the query
+     */
+    matched: boolean;
+    /**
+     * Array of explanations for each filter
+     */
+    reasons: IFilterExplanation[];
+    /**
+     * Summary of all reasons for the result matching the query
+     */
+    summary: IMatchReason[];
+}
+export interface IQueryExplanationDetails {
+    value: string;
+    description: string;
+    details: [];
+}
+/**
+ * Explanation of why a filter matched a query
+ */
+export interface IFilterExplanation {
+    /**
+     * Copy of the Filter
+     */
+    filter: IFilter;
+    /**
+     * Did the filter match the query?
+     */
+    matched: boolean;
+    /**
+     * Array of explanations for each predicate in the Filter
+     */
+    reasons: IPredicateExplanation[];
+}
+/**
+ * Explanation of why a predicate matched a query
+ */
+export interface IPredicateExplanation {
+    /**
+     * Copy of the Predicate
+     */
+    predicate: IPredicate;
+    /**
+     * Did the predicate match the query?
+     */
+    matched: boolean;
+    /**
+     * Array of reasons why the predicate matched the query
+     */
+    reasons: IMatchReason[];
+    /**
+     * Additional information about the predicate which can be useful
+     * when preparing a UI to display the explanation
+     */
+    meta?: Record<string, any>;
+}
+/**
+ * Match condition
+ */
+export declare type MatchCondition = "IN" | "NOT_IN" | "ALL";
+/**
+ * Reason why a result matched a query
+ */
+export interface IMatchReason {
+    attribute: string;
+    values?: string;
+    condition?: MatchCondition;
+    matched: boolean;
+    requirement?: string;
+    message?: string;
+    meta?: Record<string, any>;
+}
+/**
+ * Wide type allowing any object to be passed in as a result
+ */
+export declare type GenericResult = Record<string, any>;
+/**
+ * Explain why a specific result was included in a Query.
+ *
+ * NOTE: This only works for entityType: "item" queries and does not
+ * cover all possible permutations.
+ * @param queryResult
+ * @param query
+ * @param requestOptions
+ * @returns
+ */
+export declare function explainQueryResult(queryResult: GenericResult, query: IQuery, requestOptions: IRequestOptions): Promise<IQueryExplanation>;

package/dist/types/sites/_internal/SiteUiSchemaFollowers.d.ts

@@ -0,0 +1,11 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IUiSchema } from "../../core/schemas/types";
+import { IHubSite } from "../../core/types";
+/**
+ * @private
+ * constructs the followers uiSchema for Hub Sites.
+ * This defines how the schema properties should
+ * be rendered in the site followers > settings
+ * experience
+ */
+export declare const buildUiSchema: (i18nScope: string, entity: IHubSite, context: IArcGISContext) => Promise<IUiSchema>;

package/dist/types/sites/_internal/_migrate-summary-stat-card-configs.d.ts

@@ -0,0 +1,9 @@
+import { IModel, IDraft } from "../../types";
+/**
+ * Reconfigure summary stat card properties to align with the
+ * new web component card.
+ * @private
+ * @param {Object} model Site Model
+ * @returns {Object}
+ */
+export declare function _migrateSummaryStatCardConfigs<T extends IModel | IDraft>(model: T): T;

package/dist/types/sites/_internal/applyCatalogStructureMigration.d.ts

@@ -0,0 +1,11 @@
+import { IModel } from "../../types";
+/**
+ * Add the default catalog structure to the Site model
+ * Note: This in-memory migration is only applies via `fetchSite(..):IHubSite` and not
+ * the older `getSiteById(...):IModel`. Changes made in this migration will not be
+ * persisted to AGO until all other parts of the application stop relying on the legacy
+ * catalog implementation
+ * @param model
+ * @returns
+ */
+export declare function applyCatalogStructureMigration(model: IModel): IModel;

package/dist/types/sites/_internal/applyDefaultCollectionMigration.d.ts

@@ -0,0 +1,21 @@
+import { IModel } from "../../types";
+/**
+ * In-Memory migration that adds default collections to site models that have the
+ * new catalog structure. These default collections will have the same names and
+ * display order found in `site.data.values.searchCategories`
+ *
+ * This migration simplifies display logic, as consuming components no longer
+ * have to merge `catalog.collections` with the default collection definitions.
+ *
+ * This migration also lays the foundation for customization, since editors will
+ * be able to modify these persisted default objects. For example, editors can
+ * change the default labels, display order, or mark a default as "hidden" so the
+ * public can't see it.
+ *
+ * NOTE: The changes made in this migration will not be persisted to AGO at this time
+ *
+ * @param model site model to migrate
+ * @returns a migrated model with default `IHubCollectionPersistance` objects added
+ * to the catalog
+ */
+export declare function applyDefaultCollectionMigration(model: IModel): IModel;

package/dist/types/sites/_internal/capabilities/capabilityToFeatureMap.d.ts

@@ -0,0 +1,14 @@
+import { ICapabilityToFeatureMap } from "./types";
+/**
+ * Returns an array of ICapabilityToFeatureMap objects
+ * that define the projection of legacy capabilities
+ * to permission features.
+ *
+ * We use this map to manage foward and backard conversions
+ * and migration of legacy capablities to features when a
+ * site is fetched or updated
+ *
+ * NOTE: if you are porting a legacy capability over to
+ * workspaces, add it to this map
+ */
+export declare const capabilityToFeatureMap: ICapabilityToFeatureMap[];

package/dist/types/sites/_internal/capabilities/convertFeaturesToLegacyCapabilities.d.ts

@@ -0,0 +1,19 @@
+import { IModel } from "../../../types";
+/**
+ * Site capabilities are currently saved as an array on the
+ * site.data.values.capabilities. We want to migragte these
+ * legacy capabilities over to features in the new permissions
+ * system; however, we must continue persisting updates to
+ * these features in the legacy capabilities array until the
+ * existing site capabilities in our application are plumbed
+ * to work off of permissions
+ *
+ * This function is called within updateSite to ensure
+ * the legacy capabilities array is kept up-to-date
+ *
+ * TODO: Remove once site capabilities use permissions
+ *
+ * @param modelToUpdate
+ * @param currentModel
+ */
+export declare const convertFeaturesToLegacyCapabilities: (modelToUpdate: IModel, currentModel: IModel) => IModel;

package/dist/types/sites/_internal/capabilities/migrateLegacyCapabilitiesToFeatures.d.ts

@@ -0,0 +1,12 @@
+import { IModel } from "../../../types";
+/**
+ * Site capabilities are currently saved as an array on the
+ * site.data.values.capabilities. We want to migragte these
+ * legacy capabilities over to features in the new permissions
+ * system and expose them on the entity
+ *
+ * This function is called within fetchSite to ensure all
+ * sites have features that are kept up-to-date with the
+ * legacy capabilities array
+ */
+export declare const migrateLegacyCapabilitiesToFeatures: (model: IModel) => IModel;