@esri/hub-common 9.17.0 → 9.19.0

package/dist/types/Hub.d.ts

@@ -24,14 +24,12 @@ export interface IHubOptions {
  *
  * myHub.context.currentUser //=> {username: "casey", ...} as IUser
  *
- * const projectStore = await myHub.getProjectStore();
- *
- * const pavingProject = await projectStore.create({name: "12th Street Paving"});
+ * const pavingProject = await myHub.projects.create({name: "12th Street Paving"});
  * pavingProject.summary = "This is the 2024 planned paving of 12th Street, between 8th and 11th Ave";
- * await projectStore.update(pavingProject);
+ * await myHub.projects.update(pavingProject);
  * ```
  *
- * This is a convenience class. Hub Stores can be created
+ * This is a convenience class. Hub Managers can be created
  * directly, or the underlying functions can be imported an used
  * as need for scenarios where these class structures introduce
  * unwanted complexity
@@ -42,20 +40,18 @@ export declare class Hub {
      * an application. When authentication changes, the .context
      * property on the context manager will be replaced. As long as
      * all the fns in this class leverage properties on .context
-     * everything be kept in sync.
+     * everything will be kept in sync.
      */
     private _contextManager;
     private _projectManager;
     /**
-     * Private so we can employ a factory function should we need
+     * Private so we can employ a factory function to do
      * async work during creation
      * @param contextManager
      */
     private constructor();
     /**
-     * Factory function to construct a new HubProjectStore instance.
-     *
-     * Note: Used so that we could do async actions in the ctor.
+     * Factory function to construct a new Hub instance.
      * @param contextManager
      * @returns
      */
@@ -65,7 +61,7 @@ export declare class Hub {
      */
     get context(): import("./ArcGISContext").IArcGISContext;
     /**
-     * Create a Project Store connected to the current Hub
+     * HubProjectManager for the current Hub
      * @returns
      */
     get projects(): HubProjectManager;

package/dist/types/HubError.d.ts

@@ -1,4 +1,4 @@
-import { OperationError } from ".";
+import OperationError from "./OperationError";
 /**
  * Generic Hub Error with an Error stack as well
  * as an optional serialized OperationStack.

package/dist/types/content/_internal.d.ts

@@ -8,8 +8,11 @@
  * It's probably a good pattern to add functions here first and then
  * move them to index.ts only when they are needed by a consumer.
  */
-import { IItem } from "@esri/arcgis-rest-types/dist/types/item";
-import { BBox, IHubContent, IHubGeography, GeographyProvenance, IHubRequestOptions } from "..";
+import { ILayerDefinition, IFeatureServiceDefinition } from "@esri/arcgis-rest-feature-layer";
+import { IItem } from "@esri/arcgis-rest-portal";
+import { ISpatialReference } from "@esri/arcgis-rest-types";
+import { IHubContent } from "../core";
+import { IHubGeography, GeographyProvenance, IHubRequestOptions } from "../types";
 /**
  * Create a new content with updated boundary properties
  * @param content original content
@@ -36,7 +39,7 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
         documentation?: string;
         extent?: number[][];
         categories?: string[];
-        spatialReference?: import("@esri/arcgis-rest-types").ISpatialReference;
+        spatialReference?: ISpatialReference;
         culture?: string;
         url?: string;
     };
@@ -45,10 +48,10 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
     identifier: string;
     permissions: {
         visibility: "private" | "public" | "org";
-        control?: import("..").AccessControl;
-        groups?: import("@esri/arcgis-rest-types").IGroup[];
+        control?: import("../types").AccessControl;
+        groups?: import("@esri/arcgis-rest-portal").IGroup[];
     };
-    family?: import("..").HubFamily;
+    family?: import("../types").HubFamily;
     categories?: string[];
     isDownloadable: boolean;
     structuredLicense?: import("..").IStructuredLicense;
@@ -58,9 +61,10 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
     portalHomeUrl?: string;
     portalApiUrl?: string;
     portalDataUrl?: string;
-    actionLinks?: import("..").IActionLink[];
+    actionLinks?: import("../types").IActionLink[];
     hubActions?: object;
-    layer?: Partial<import("@esri/arcgis-rest-types").ILayerDefinition>;
+    layer?: Partial<ILayerDefinition>;
+    isProxied?: boolean;
     itemCategories?: string[];
     normalizedType?: string;
     orgId?: string;
@@ -79,17 +83,18 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
     updatedDate: Date;
     updatedDateSource: string;
     type: string;
-    server?: Partial<import("@esri/arcgis-rest-types").IFeatureServiceDefinition>;
-    layers?: Partial<import("@esri/arcgis-rest-types").ILayerDefinition>[];
-    recordCount?: number;
+    statistics?: any;
     data?: {
         [propName: string]: any;
     };
     metadata?: any;
     groupIds?: string[];
-    ownerUser?: import("@esri/arcgis-rest-types").IUser;
+    ownerUser?: import("@esri/arcgis-rest-portal").IUser;
     org?: Partial<import("@esri/arcgis-rest-portal").IPortal>;
-    errors?: import("..").IEnrichmentErrorInfo[];
+    errors?: import("../types").IEnrichmentErrorInfo[];
+    server?: Partial<IFeatureServiceDefinition>;
+    layers?: Partial<ILayerDefinition>[];
+    recordCount?: number;
     created: number;
     modified: number;
     numViews: number;
@@ -99,16 +104,11 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
     snippet?: string;
     documentation?: string;
     extent?: number[][];
-    spatialReference?: import("@esri/arcgis-rest-types").ISpatialReference;
+    spatialReference?: ISpatialReference;
     properties?: any;
 };
-/**
- * Create a new content with updated extent and derived properties like boundary
- * @param content original content
- * @param extent new extent
- * @returns a new content with the updated extent and boundary
- */
-export declare const setContentExtent: (content: IHubContent, extent: BBox) => IHubContent;
+export declare const getContentBoundary: (item: IItem) => IHubGeography;
+export declare const isPortal: (requestOptions?: IHubRequestOptions) => boolean;
 /**
  * Returns whether or not an item is a proxied csv
  *
@@ -116,4 +116,39 @@ export declare const setContentExtent: (content: IHubContent, extent: BBox) => I
  * @param requestOptions Hub Request Options (including whether we're in portal)
  * @returns
  */
-export declare const isProxiedCSV: (item: IItem, requestOptions: IHubRequestOptions) => boolean;
+export declare const isProxiedCSV: (item: IItem, requestOptions?: IHubRequestOptions) => boolean;
+export declare const getHubRelativeUrl: (type: string, identifier: string, typeKeywords?: string[]) => string;
+export declare const isPageType: (type: string) => boolean;
+export interface IMetadataPaths {
+    updateFrequency: string;
+    metadataUpdateFrequency: string;
+    metadataUpdatedDate: string;
+    reviseDate: string;
+    pubDate: string;
+    createDate: string;
+}
+export declare function getMetadataPath(identifier: keyof IMetadataPaths): string;
+export declare function getValueFromMetadata(metadata: any, identifier: keyof IMetadataPaths): any;
+export declare enum DatePrecision {
+    Year = "year",
+    Month = "month",
+    Day = "day",
+    Time = "time"
+}
+/**
+ * Parses an ISO8601 date string into a date and a precision.
+ * This is because a) if somone entered 2018, we want to respect that and not treat it as the same as 2018-01-01
+ * and b) you cannot naively call new Date with an ISO 8601 string that does not include time information
+ * For example, when I, here in mountain time, do new Date('2018').getFullYear() I get "2017".
+ * This is because when you do not provide time or timezone info, UTC is assumed, so new Date('2018') is 2018-01-01T00:00:00 in UTC
+ * which is actually 7 hours earlier here in mountain time.
+ *
+ * @param {string} isoString
+ * @return { date: Date, precision: DatePrecision }
+ */
+export declare function parseISODateString(isoString: string): {
+    date: Date;
+    precision: DatePrecision;
+};
+export declare const getServerSpatialReference: (server: Partial<IFeatureServiceDefinition>, layer?: ILayerDefinition) => ISpatialReference;
+export declare const getItemSpatialReference: (item: IItem) => ISpatialReference;

package/dist/types/content/compose.d.ts

@@ -0,0 +1,115 @@
+import { IItem } from "@esri/arcgis-rest-portal";
+import { IHubRequestOptions } from "../types";
+import { IHubContentEnrichments, IHubContent } from "../core";
+/**
+ * The possible values for updateFrequency
+ *
+ * @enum {string}
+ */
+export declare enum UpdateFrequency {
+    Continual = "continual",
+    Daily = "daily",
+    Weekly = "weekly",
+    Fortnightly = "fortnightly",
+    Monthly = "monthly",
+    Quarterly = "quarterly",
+    Biannually = "biannually",
+    Annually = "annually",
+    AsNeeded = "as-needed",
+    Irregular = "irregular",
+    NotPlanned = "not-planned",
+    Unknown = "unknown",
+    Semimonthly = "semimonthly"
+}
+/**
+ * DEPRECATED: Compute the content type icon based on the content type
+ * @param content type
+ * @returns content type icon
+ */
+export declare const getContentTypeIcon: (contentType: string) => any;
+/**
+ * get portal URLs (home, API, data, and thumbnail) for an item
+ *
+ * @param item Item
+ * @param requestOptions Request options
+ * @returns a hash with the portal URLs
+ * @export
+ */
+export declare const getPortalUrls: (item: IItem, requestOptions: IHubRequestOptions) => {
+    portalHome: string;
+    portalApi: string;
+    portalData: string;
+    thumbnail: string;
+};
+/**
+ * If an item is a proxied csv, returns the url for the proxying feature layer.
+ * If the item is not a proxied csv, returns undefined.
+ *
+ * @param item
+ * @param requestOptions Hub Request Options (including whether we're in portal)
+ * @returns
+ */
+export declare const getProxyUrl: (item: IItem, requestOptions?: IHubRequestOptions) => string;
+/**
+ * parse layer id from a service URL
+ * @param {string} url
+ * @returns {string} layer id
+ */
+export declare const getLayerIdFromUrl: (url: string) => string;
+/**
+ * Case-insensitive check if the type is "Feature Service"
+ * @param {string} type - item's type
+ * @returns {boolean}
+ */
+export declare const isFeatureService: (type: string) => boolean;
+/**
+ * ```js
+ * import { normalizeItemType } from "@esri/hub-common";
+ * //
+ * normalizeItemType(item)
+ * > [ 'Hub Site Application' ]
+ * ```
+ * @param item Item object.
+ * @returns type of the input item.
+ *
+ */
+export declare function normalizeItemType(item?: any): string;
+/**
+ * return the layerId if we can tell that item is a single layer service
+ * @param {*} item from AGO
+ * @returns {string} layer id
+ */
+export declare const getItemLayerId: (item: IItem) => string;
+/**
+ * given an item, get the id to use w/ the Hub API
+ * @param item
+ * @returns Hub API id (hubId)
+ */
+export declare const getItemHubId: (item: IItem) => string;
+/**
+ * Splits item category strings at slashes and discards the "Categories" keyword
+ *
+ * ```
+ * ["/Categories/Boundaries", "/Categories/Planning and cadastre/Property records", "/Categories/Structure"]
+ * ```
+ * Should end up being
+ * ```
+ * ["Boundaries", "Planning and cadastre", "Property records", "Structure"]
+ * ```
+ *
+ * @param categories - an array of strings
+ * @private
+ */
+export declare function parseItemCategories(categories: string[]): string[];
+export interface IComposeContentOptions extends IHubContentEnrichments {
+    layerId?: number;
+    slug?: string;
+    requestOptions?: IHubRequestOptions;
+}
+/**
+ * Compose a new content object out of an item, enrichments, and context
+ * @param item
+ * @param options any enrichments, current state (selected layerId), or context (requestOptions)
+ * @returns new content object
+ */
+export declare const composeContent: (item: IItem, options?: IComposeContentOptions) => IHubContent;

package/dist/types/content/get-family.d.ts

@@ -0,0 +1,7 @@
+import { HubFamily } from "../types";
+/**
+ * return the Hub family given an item's type
+ * @param type item type
+ * @returns Hub family
+ */
+export declare function getFamily(type: string): HubFamily;

package/dist/types/content/index.d.ts

@@ -1,7 +1,9 @@
 import { ResourceObject } from "jsonapi-typescript";
 import { IItem } from "@esri/arcgis-rest-portal";
-import { HubType, HubFamily, IModel, IHubRequestOptions } from "../types";
-import { IHubContent } from "..";
+import { HubType, IModel } from "../types";
+import { IHubContent } from "../core";
+export * from "./compose";
+export * from "./get-family";
 /**
  * JSONAPI dataset resource returned by the Hub API
  */
@@ -34,18 +36,6 @@ export declare function getCategory(itemType?: string): string;
  *
  */
 export declare function getTypes(category?: string): string[];
-/**
- * ```js
- * import { normalizeItemType } from "@esri/hub-common";
- * //
- * normalizeItemType(item)
- * > [ 'Hub Site Application' ]
- * ```
- * @param item Item object.
- * @returns type of the input item.
- *
- */
-export declare function normalizeItemType(item?: any): string;
 /**
  * ```js
  * import { getTypeCategories } from "@esri/hub-common";
@@ -58,42 +48,6 @@ export declare function normalizeItemType(item?: any): string;
  *
  */
 export declare function getTypeCategories(item?: any): string[];
-/**
- * ```js
- * import { getCollection } from "@esri/hub-common";
- * //
- * getCollection('Feature Layer')
- * > 'dataset'
- * ```
- * Get the Hub collection for a given item type
- * @param itemType The ArcGIS [item type](https://developers.arcgis.com/rest/users-groups-and-items/items-and-item-types.htm).
- * @returns the Hub collection of a given item type.
- */
-export declare function getCollection(itemType?: string): string;
-/**
- * Case-insensitive check if the type is "Feature Service"
- * @param {string} type - item's type
- * @returns {boolean}
- */
-export declare const isFeatureService: (type: string) => boolean;
-/**
- * parse layer id from a service URL
- * @param {string} url
- * @returns {string} layer id
- */
-export declare const getLayerIdFromUrl: (url: string) => string;
-/**
- * return the layerId if we can tell that item is a single layer service
- * @param {*} item from AGO
- * @returns {string} layer id
- */
-export declare const getItemLayerId: (item: IItem) => string;
-/**
- * given an item, get the id to use w/ the Hub API
- * @param item
- * @returns Hub API id (hubId)
- */
-export declare const getItemHubId: (item: IItem) => string;
 /**
  * ```js
  * import { getContentIdentifier } from "@esri/hub-common";
@@ -149,27 +103,6 @@ export declare function addContextToSlug(slug: string, context: string): string;
  * @returns slug without context
  */
 export declare function removeContextFromSlug(slug: string, context: string): string;
-/**
- * Splits item category strings at slashes and discards the "Categories" keyword
- *
- * ```
- * ["/Categories/Boundaries", "/Categories/Planning and cadastre/Property records", "/Categories/Structure"]
- * ```
- * Should end up being
- * ```
- * ["Boundaries", "Planning and cadastre", "Property records", "Structure"]
- * ```
- *
- * @param categories - an array of strings
- * @private
- */
-export declare function parseItemCategories(categories: string[]): string[];
-/**
- * return the Hub family given an item's type
- * @param type item type
- * @returns Hub family
- */
-export declare function getFamily(type: string): HubFamily;
 /**
  * DEPRECATED: Use getFamily() instead.
  *
@@ -210,12 +143,6 @@ export declare function datasetToItem(dataset: DatasetResource): IItem;
  * @returns new content
  */
 export declare const setContentType: (content: IHubContent, type: string) => IHubContent;
-/**
- * Compute the content type icon based on the content type
- * @param content type
- * @returns content type icon
- */
-export declare const getContentTypeIcon: (contentType: string) => any;
 /**
  * Compute the content type label
  * @param contentType
@@ -249,12 +176,3 @@ export declare const getContentSiteUrls: (content: IHubContent, siteModel: IMode
  * @returns
  */
 export declare const setContentSiteUrls: (content: IHubContent, siteModel: IModel) => IHubContent;
-/**
- * If an item is a proxied csv, returns the url for the proxying feature layer.
- * If the item is not a proxied csv, returns undefined.
- *
- * @param item
- * @param requestOptions Hub Request Options (including whether we're in portal)
- * @returns
- */
-export declare const getProxyUrl: (item: IItem, requestOptions: IHubRequestOptions) => string;

package/dist/types/core/types/IHubContent.d.ts

@@ -2,11 +2,11 @@ import { IItem, IGroup } from "@esri/arcgis-rest-portal";
 import { ILayerDefinition } from "@esri/arcgis-rest-feature-layer";
 import { Visibility, AccessControl, HubFamily, IActionLink, IStructuredLicense } from "../..";
 import { IHubItemEntity } from ".";
-import { IContentEnrichments } from "./IContentEnrichments";
+import { IHubContentEnrichments } from "./IHubContentEnrichments";
 /**
  * Data model for content
  */
-export interface IHubContent extends IHubItemEntity, IContentEnrichments, IItem {
+export interface IHubContent extends IHubItemEntity, IHubContentEnrichments, IItem {
     /**
      * The underlying portal item referenced by this content
      */
@@ -71,6 +71,8 @@ export interface IHubContent extends IHubItemEntity, IContentEnrichments, IItem
     hubActions?: object;
     /** Information about the layer referenced by this content (geometryType, fields, etc) */
     layer?: Partial<ILayerDefinition>;
+    /** Whether or not the layer or table is actually a proxied CSV */
+    isProxied?: boolean;
     itemCategories?: string[];
     normalizedType?: string;
     orgId?: string;

package/dist/types/core/types/IHubContentEnrichments.d.ts

@@ -0,0 +1,15 @@
+import { IHubGeography } from "../../types";
+import { IItemEnrichments } from "./IItemEnrichments";
+import { IServerEnrichments } from "./IServerEnrichments";
+export interface IHubContentEnrichments extends IItemEnrichments, IServerEnrichments {
+    /**
+     * boundary will default to the item extent
+     * but can be overwritten by enrichments from the Hub API (inline)
+     * or fetched from a location such as /resources/boundary.json
+     */
+    boundary?: IHubGeography;
+    /**
+     *
+     */
+    statistics?: any;
+}

package/dist/types/core/types/IHubEntityManager.d.ts

@@ -1,5 +1,6 @@
 import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
 import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { Filter, IHubSearchOptions, ISearchResponse } from "../..";
 /**
  * Baseline CRUD+Search functions required for all Store classes
  */
@@ -30,4 +31,19 @@ export interface IHubEntityManager<T> {
      * @param requestOptions
      */
     fetch(identifier: string, requestOptions: IRequestOptions): Promise<T>;
+    /**
+     * [WIP] We need to work out how best to handle the typing on this. Simply
+     * delegating to `searchContent` with a filter constraining to an Entity type
+     * will return `ISearchResponse<IHubContent>` and not the expected type.
+     *
+     * Search for Entitys of type `T`
+     *
+     * Note: When implementing, this should be a search for things of type `T`
+     * not searching "within" the `T`.
+     *
+     * i.e. Searching for Teams, not searching for content shared to a team.
+     * @param filter
+     * @param opts
+     */
+    search(filter: Filter<"content">, opts: IHubSearchOptions): Promise<ISearchResponse<T>>;
 }

package/dist/types/core/types/IHubItemEntity.d.ts

@@ -1,5 +1,5 @@
 import { IHubEntityBase } from "./IHubEntityBase";
-import { IHubGeography } from "../..";
+import { IHubGeography } from "../../types";
 /**
  * Properties exposed by Entities that are backed by Items
  */

package/dist/types/core/types/IHubItemEntityManager.d.ts

@@ -0,0 +1,15 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Item specific functions that must be implemented by Managers which operate against
+ * items stored in the Portal API
+ */
+export interface IHubItemEntityManager<T> {
+    /**
+     * Add a thumbnail to an item
+     * @param entity
+     * @param file
+     * @param name
+     * @param requestOptions
+     */
+    updateThumbnail(entity: T, file: any, filename: string, requestOptions?: IUserRequestOptions): Promise<T>;
+}

package/dist/types/core/types/{IContentEnrichments.d.ts → IServerEnrichments.d.ts}

@@ -1,6 +1,5 @@
 import { IFeatureServiceDefinition, ILayerDefinition } from "@esri/arcgis-rest-feature-layer";
-import { IItemEnrichments } from "./IItemEnrichments";
-export interface IContentEnrichments extends IItemEnrichments {
+export interface IServerEnrichments {
     /** Information about the service referenced by this content (currentVersion, capabilities, maxRecordCount etc) */
     server?: Partial<IFeatureServiceDefinition>;
     /** Detailed information about the service's layers (geometryType, fields, etc) for related layers in the service */
@@ -8,3 +7,5 @@ export interface IContentEnrichments extends IItemEnrichments {
     /** The count of records for the layer referenced by this content */
     recordCount?: number;
 }
+export interface IContentEnrichments extends IServerEnrichments {
+}

package/dist/types/core/types/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./IContentEnrichments";
 export * from "./IItemEnrichments";
+export * from "./IHubContentEnrichments";
 export * from "./IHubContent";
 export * from "./IHubEntityBase";
 export * from "./IHubItemEntity";
@@ -12,3 +12,4 @@ export * from "./IHubPage";
 export * from "./IHubProject";
 export * from "./IHubSite";
 export * from "./IHubTimeline";
+export * from "./IServerEnrichments";

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

@@ -15,3 +15,4 @@ export * from "./fetch-all-pages";
 export * from "./get-structured-license";
 export * from "./slugs";
 export * from "./normalize-solution-template-item";
+export * from "./setItemThumbnail";

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

@@ -0,0 +1,9 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Upload a file to be used as the thumbnail for an item
+ * @param id
+ * @param file
+ * @param filename
+ * @param requestOptions
+ */
+export declare function setItemThumbnail(id: string, file: any, filename: string, requestOptions: IUserRequestOptions): Promise<void>;

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

@@ -28,6 +28,22 @@ export declare function setSlugKeyword(typeKeywords: string[], slug: string): st
  * @returns
  */
 export declare function getItemBySlug(slug: string, requestOptions: IRequestOptions): Promise<IItem>;
+/**
+ * Find items by slug typeKeywords.
+ *
+ * Optional exclude parameter accepts the id of an item we expect to
+ * have this particular slug. This is used during update calls
+ * where we don't know if the slug specifically has been updated, but we
+ * don't want a false-postive from the item we are updating
+ *
+ * @param slug
+ * @param requestOptions
+ * @returns
+ */
+export declare function findItemsBySlug(slugInfo: {
+    slug: string;
+    exclude?: string;
+}, requestOptions: IRequestOptions): Promise<IItem[]>;
 /**
  * Given a slug, search for items using that slug, incrementing the slug name until
  * a unique value is found
@@ -40,4 +56,7 @@ export declare function getItemBySlug(slug: string, requestOptions: IRequestOpti
  * @param step
  * @returns
  */
-export declare function getUniqueSlug(slug: string, requestOptions: IRequestOptions, step?: number): Promise<string>;
+export declare function getUniqueSlug(slugInfo: {
+    slug: string;
+    existingId?: string;
+}, requestOptions: IRequestOptions, step?: number): Promise<string>;

package/dist/types/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./serializeModel";
 import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+import { IItem } from "@esri/arcgis-rest-portal";
 import { IRequestOptions } from "@esri/arcgis-rest-request";
 import { IModel } from "..";
 /**
@@ -40,3 +41,10 @@ export declare function createModel(model: IModel, requestOptions: IUserRequestO
  * @returns {Promise<IModel>}
  */
 export declare function updateModel(model: IModel, requestOptions: IUserRequestOptions): Promise<IModel>;
+/**
+ * Given an Item, fetch the data json and return an IModel
+ * @param item
+ * @param requestOptions
+ * @returns
+ */
+export declare function fetchModelFromItem(item: IItem, requestOptions: IRequestOptions): Promise<IModel>;