@arcgis/core 5.0.0-next.51 → 5.0.0-next.53

package/linkChart/LinkChartProperties.d.ts

@@ -1,4 +1,73 @@
-import "../interfaces";
+import type LayoutSettings from "./LayoutSettings.js";
+import type NonspatialDataDisplay from "./NonspatialDataDisplay.js";
+import type { ClonableMixin, ClonableMixinProperties } from "../core/Clonable.js";
+import type { MultiOriginJSONSupport, MultiOriginJSONMixinProperties } from "../core/MultiOriginJSONSupport.js";
+import type { LayoutType as LayoutTypeJSON } from "../portal/jsonTypes.js";
 
-import LinkChartProperties = __esri.LinkChartProperties;
-export default LinkChartProperties;
+export interface LinkChartPropertiesProperties extends MultiOriginJSONMixinProperties, ClonableMixinProperties {}
+
+/**
+ * Properties that contain source information, layout configurations and other settings for a Link chart.
+ *
+ * @since 4.31
+ * @see [Web Map Specification | Link chart Properties](https://developers.arcgis.com/web-map-specification/objects/linkChartProperties/)
+ */
+export default class LinkChartProperties extends LinkChartPropertiesSuperclass {
+  constructor(properties?: LinkChartPropertiesProperties);
+  /** Additional settings for chronological and organic link chart layouts. */
+  get layoutSettings(): LayoutSettings | null | undefined;
+  /**
+   * The link chart layout algorithm used to position entities and relationships on the link chart.
+   * Link chart layouts fall into different categories depending on how they organize entities and relationships in the link chart.
+   *
+   * - **Chronological** layouts arrange entities and relationships using time. Entities with time properties, called event entities,
+   * and relationships with time properties, called event relationships, will be arranged on one or multiple timelines in the order
+   * that they occurred. The entity type or relationship type must have a time property and the layer must be time enabled for an entity
+   * or relationship to be considered an event.
+   * - **Organic** layouts consider the link chart as if it were a mechanical system. The entities repel each other like two magnets
+   * aligned with the same poles facing each other, while they are attracted to each other by the relationships that join entities together.
+   * The algorithm iteratively reviews and places entities and evaluates the forces until equilibrium is reached.
+   * [Settings](https://developers.arcgis.com/javascript/latest/api-reference/esri-linkChart-LayoutSettings.html) allow you to customize how entities are placed. These layouts allow you to visualize
+   * entities in clusters that emphasize how they are connected.
+   * - **Hierarchical** layouts attempt to orient the majority of the relationships from the bottom to the top in which
+   *  the origins for the relationship are positioned at the bottom and destination entities are positioned at the top.
+   * The algorithm attempts to limit the number of places in which the lines representing relationships cross each other.
+   * Relationships are not allowed between entities at the same level in the link chart.
+   * - **Tree** layouts arrange entities and their relationships as in nature, where the tree starts from the trunk and all branches
+   *  move out from that point. In the link chart, the root entity is the starting point, the entities related to the root entity are then lined up
+   * in a row next to the root entity, from left to right in this example. Radial layouts are a particular form of tree layout where the root of the
+   * tree is placed in the center of a circle and the entities to which it is related are positioned in a circle around the root.The algorithm
+   * identifies the entity associated with the smallest network topology index and uses it as the root entity.
+   *
+   * Layout Type                   | Layout Category | Description|
+   * ------------------------------|---------------- |------------|
+   * basic-grid                    | Basic           | This layout arranges entities in a regularly spaced lattice pattern, where the size of the grid depends of the number of entities |
+   * chronological-mono-timeline   | Chronological   | This layout arranges all events in a single time line. By default, the direction of time is left to right and events that overlap in time are arranged vertically.
+   * chronological-multi-timeline  | Chronological   | This layout creates individual time lines for each entity related to an event. Event entities are placed between the time lines. Relationships are drawn between a time line and the connected event entity. Relationships connecting events that have both a start and end time, also called durative events, will have a right angle. The portion along the time line represents the duration of the event. The layout will arrange entities and relationships depending on the type of event.
+   * geographic-organic-standard   | Organic         | This layout arranges spatial entities geographically using their geometry. Spatial entities in which the entity has a null geometry and nonspatial entities are displayed on the link chart, but their placement and arrangement are determined using the `organic-standard` layout. The basemap defined in the [WebLinkChart](https://developers.arcgis.com/javascript/latest/api-reference/esri-WebLinkChart.html) is used by default as a backdrop to provide spatial context.
+   * hierarchical-bottom-to-top    | Hierarchical    | This layout is arranged similarly to tree layouts. However, an attempt is made to orient the majority of the relationships from the bottom to the top in which the origins for the relationship are positioned at the bottom and destination entities are positioned at the top. The algorithm attempts to limit the number of places in which the lines representing relationships cross each other. In contrast with the tree layouts, relationships are not allowed between entities at the same level in the link chart with this layout.
+   * organic-community             | Organic         | This layout finds communities, which are groups of entities that are closely related to each other. An `organic-standard` layout is then used to arrange the communities. The attraction forces along relationships between entities of different communities are relaxed so that different communities are more spread out.
+   * organic-standard              | Organic         | This layout considers the link chart as if it were a mechanical system. The entities repel each other like two magnets aligned with the same poles facing each other, while they are attracted to each other by the relationships that join entities together. The algorithm iteratively reviews and places entities and evaluates the forces until equilibrium is reached. This layout allows you to visualize entities in clusters that emphasize how they are connected.
+   * radial-node-centric           | Tree            | This layout arranges entities and their relationships as in nature, where the tree starts from the trunk and all branches move out from that point. In the link chart, the root entity is the starting point, positioned at the left. The entities related to the root entity are lined up in a row to the right of the root entity, from top to bottom in this example. Any entities related to those items that aren't present in the link chart are added as another row closer to the bottom, and so on. The algorithm identifies the entity associated with the smallest network topology index and uses it as the root entity.
+   * tree-right-to-left            | Tree            | This layout places the root entity for the tree in the center of a circle. All leaf entities for the tree are positioned around the outer edge of the circle. Entities at each level of hierarchy in the tree are arranged in concentric circles between the root entity and the outer circle.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitation**
+   * >
+   * > The layouts that are currently supported are those listed in the table above.
+   *
+   * @default "organic-standard"
+   */
+  get layoutType(): LayoutTypeJSON;
+  /**
+   * Object that defines instructions on the visualization of nonspatial link chart data.
+   * Link charts can contain both spatial and nonspatial records. Spatial records are entities with geometry and relationships that
+   * connect two spatial entities (both the relationship origin and destination entities have geometry). Nonspatial records are entities without
+   * geometry (even if they are a member of a spatially enabled entity type) and relationships that have at least one endpoint with no geometry.
+   */
+  get nonspatialDataDisplay(): NonspatialDataDisplay | null | undefined;
+  /** Url pointing to a resource containing featureSet as PBF reference containing a serialized representation of the internal entity table. */
+  get relationshipsUrl(): string | null | undefined;
+}
+declare const LinkChartPropertiesSuperclass: typeof MultiOriginJSONSupport & typeof ClonableMixin

package/linkChart/NonspatialDataDisplay.d.ts

@@ -1,4 +1,24 @@
-import "../interfaces";
+import type { ClonableMixin, ClonableMixinProperties } from "../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../core/JSONSupport.js";
 
-import NonspatialDataDisplay = __esri.NonspatialDataDisplay;
-export default NonspatialDataDisplay;
+export interface NonspatialDataDisplayProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<NonspatialDataDisplay, "mode">> {}
+
+/**
+ * Object that defines instructions on the visualization of nonspatial link chart data.
+ * Link charts can contain both spatial and nonspatial records. Spatial records are entities with geometry and relationships that
+ * connect two spatial entities (both the relationship origin and destination entities have geometry). Nonspatial records are entities without
+ * geometry (even if they are a member of a spatially enabled entity type) and relationships that have at least one endpoint with no geometry.
+ *
+ * @since 4.32
+ * @see [Web Map Specification | Link chart layout settings](https://developers.arcgis.com/web-map-specification/objects/nonspatialDataDisplay/)
+ */
+export default class NonspatialDataDisplay extends NonspatialDataDisplaySuperclass {
+  constructor(properties?: NonspatialDataDisplayProperties);
+  /**
+   * Mode for how nonspatial information should be displayed.
+   *
+   * @default "visible"
+   */
+  accessor mode: "hidden" | "visible";
+}
+declare const NonspatialDataDisplaySuperclass: typeof JSONSupport & typeof ClonableMixin

package/linkChart/OrganicLayoutSettings.d.ts

@@ -1,4 +1,57 @@
-import "../interfaces";
+import type { ClonableMixin, ClonableMixinProperties } from "../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../core/JSONSupport.js";
+import type { IdealEdgeLengthType } from "./interfaces.js";
 
-import OrganicLayoutSettings = __esri.OrganicLayoutSettings;
-export default OrganicLayoutSettings;
+export interface OrganicLayoutSettingsProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<OrganicLayoutSettings, "absoluteIdealEdgeLength" | "autoRepulsionRadius" | "computationBudgetTime" | "idealEdgeLengthType" | "multiplicativeIdealEdgeLength" | "repulsionRadiusMultiplier">> {}
+
+/**
+ * Settings for organic layout calculations.
+ *
+ * @since 4.32
+ * @see [Web Map Specification | Link chart organic layout settings](https://developers.arcgis.com/web-map-specification/objects/linkChartOrganicLayoutSettings/)
+ */
+export default class OrganicLayoutSettings extends OrganicLayoutSettingsSuperclass {
+  constructor(properties?: OrganicLayoutSettingsProperties);
+  /**
+   * The value, in degrees, to use for the ideal edge length during layout calculations when the {@link linkChart/OrganicLayoutSettings#idealEdgeLenghtType idealEdgeLengthType} is `absolute-value`.
+   * Only used for geographic layouts.
+   *
+   * @default 1
+   */
+  accessor absoluteIdealEdgeLength: number;
+  /**
+   * Determines whether the repulsion radius should be calculated automatically (`true`), or computed according to `repulsionRadiusMultiplier` (`false`).
+   *
+   * @default true
+   */
+  accessor autoRepulsionRadius: boolean;
+  /**
+   * The maximum amount of time in seconds to spend on the layout calculation.
+   *
+   * @default 2
+   */
+  accessor computationBudgetTime: number | null | undefined;
+  /**
+   * Determines which property to use to compute the ideal edge length. Only used for geographic layouts.
+   * When the value is `absolute-value`, the `absoluteIdealEdgeLength` property is used.
+   * When the value is `multiplier`, the `multiplicativeIdealEdgeLength` property is used.
+   *
+   * @default "multiplier"
+   */
+  idealEdgeLengthType: IdealEdgeLengthType;
+  /**
+   * Value used to multiply the default edge length to determine the ideal edge length during layout calculations, when the [idealEdgeLengthType](https://developers.arcgis.com/javascript/latest/api-reference/esri-linkChart-OrganicLayoutSettings.html#idealEdgeLengthType) is `multiplier`.
+   * Only used for geographic layouts.
+   *
+   * @default 1
+   */
+  accessor multiplicativeIdealEdgeLength: number;
+  /**
+   * Value to be used for the repulsion radius multiplier in organic layout calculations.
+   * The repulsion radius is calculated by multiplying the repulsionRadiusMultiplier by the actual ideal edge length.
+   *
+   * @default 1
+   */
+  accessor repulsionRadiusMultiplier: number | null | undefined;
+}
+declare const OrganicLayoutSettingsSuperclass: typeof JSONSupport & typeof ClonableMixin

package/linkChart/interfaces.d.ts

@@ -0,0 +1,4 @@
+
+export type EventsTicksVisualization = "none" | "start-and-end" | "start-only";
+
+export type IdealEdgeLengthType = "absolute-value" | "multiplier";

package/networks/CircuitManager.d.ts

@@ -1,4 +1,183 @@
-import "../interfaces";
+import type FeatureLayer from "../layers/FeatureLayer.js";
+import type UtilityNetwork from "./UtilityNetwork.js";
+import type Circuit from "./support/Circuit.js";
+import type CircuitVerifyResult from "../rest/networks/circuits/support/CircuitVerifyResult.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../core/JSONSupport.js";
+import type { CircuitExportResult, DomainNetworkJSON } from "./support/jsonTypes.js";
+import type { ExportCircuitsParametersProperties } from "../rest/networks/circuits/support/ExportCircuitsParameters.js";
+import type { QueryCircuitsParametersProperties } from "../rest/networks/circuits/support/QueryCircuitsParameters.js";
+import type { UtilityNetworkProperties } from "./UtilityNetwork.js";
 
-import CircuitManager = __esri.CircuitManager;
-export default CircuitManager;
+export interface CircuitManagerProperties extends JSONSupportMixinProperties {
+  /**
+   * An object representing the telecom domain network in the
+   * utility network data element.
+   */
+  telecomDomainNetwork?: DomainNetworkJSON;
+  /** The [UtilityNetwork](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-UtilityNetwork.html) that contains the telecom domain network being managed. */
+  utilityNetwork?: UtilityNetworkProperties;
+}
+
+/**
+ * Describes a start/stop circuit location for circuit queries.
+ *
+ * @since 4.34
+ */
+export type QueryCircuitProps = Pick<QueryCircuitsParametersProperties, "location" | "locationType" | "returnConsumerCircuits">;
+
+export type ExportCircuitsProps = Pick<ExportCircuitsParametersProperties, "circuits" | "exportAcknowledgement">;
+
+/**
+ * A CircuitManager provides access to circuit management capabilities for a telecom domain network
+ * in a utility network.
+ *
+ * @beta
+ * @since 4.34
+ * @see [UtilityNetwork](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-UtilityNetwork.html)
+ * @see [UnitIdentifierManager](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-UnitIdentifierManager.html)
+ * @see [Telecom domain network](https://pro.arcgis.com/en/pro-app/latest/help/data/utility-network/telecom-domain-networks.htm)
+ * @example
+ * const utilityNetwork = new UtilityNetwork({
+ *   layerUrl: "https://host.com/arcgis/rest/services/Test/FeatureServer/0",
+ * });
+ *
+ * await utilityNetwork.load();
+ *
+ * const domainNetworks = utilityNetwork.dataElement?.domainNetworks;
+ * const telecomDomainNetwork = domainNetworks.find((dn) => dn.isTelecomNetwork);
+ *
+ * const circuitManager = await utilityNetwork.getCircuitManager(telecomDomainNetwork.domainNetworkName);
+ */
+export default class CircuitManager extends JSONSupport {
+  constructor(properties?: CircuitManagerProperties);
+  /** A [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the telecom domain network's circuit section table. */
+  get circuitSectionTable(): FeatureLayer;
+  /** A [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the telecom domain network's circuit table. */
+  get circuitTable(): FeatureLayer;
+  /**
+   * Returns the root feature service URL which the utility network is part of.
+   *
+   * @example `https://utilitynetwork.esri.com/server/rest/services/NapervilleElectric/FeatureServer/`
+   */
+  get featureServiceUrl(): string;
+  /**
+   * The version of the geodatabase of the feature service data used by the utility network.
+   * Read the [Overview of versioning](https://pro.arcgis.com/en/pro-app/latest/help/data/geodatabases/overview/overview-of-versioning-in-arcgis-pro.htm)
+   * topic for more details about this capability.
+   */
+  get gdbVersion(): string | null | undefined;
+  /**
+   * The utility network's historic moment to query.
+   * If this property is not specified, queries will apply to the current features.
+   */
+  get historicMoment(): Date | null | undefined;
+  /**
+   * The URL of the network server.
+   *
+   * @example `https://utilitynetwork.esri.com/server/rest/services/NapervilleElectric/UtilityNetworkServer/`
+   */
+  get networkServiceUrl(): string;
+  /** A [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the telecom domain network's subcircuit table. */
+  get subcircuitTable(): FeatureLayer;
+  /**
+   * An object representing the telecom domain network in the
+   * utility network data element.
+   */
+  get telecomDomainNetwork(): DomainNetworkJSON;
+  /** The name of the telecom domain network. */
+  get telecomDomainNetworkName(): string;
+  /** The [UtilityNetwork](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-UtilityNetwork.html) that contains the telecom domain network being managed. */
+  get utilityNetwork(): UtilityNetwork;
+  /**
+   * Modifies circuit information for an existing circuit in a telecom domain network.
+   * This method replaces the existing circuit definition with the provided circuit.
+   * If any properties are excluded from the provided circuit definition, it is removed from the circuit.
+   *
+   * To alter an existing circuit, the provided [Circuit](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-support-Circuit.html) must
+   * have a valid `globalId` property, else this method will throw an exception.
+   *
+   * @param circuit - The circuit to be altered.
+   * @returns Resolves when the circuit is successfully altered.
+   */
+  alter(circuit: Circuit): Promise<void>;
+  /**
+   * Creates a circuit in a telecom domain network.
+   *
+   * @param circuit - The circuit to create.
+   * @returns Resolves when the circuit is successfully created.
+   */
+  create(circuit: Circuit): Promise<void>;
+  /**
+   * Logically deletes one or more circuits in a telecom domain network.
+   *
+   * @param circuitNames - The names of the circuit or circuits to be deleted.
+   * @returns Resolves when the specified circuits are successfully deleted.
+   */
+  delete(circuitNames: string[]): Promise<void>;
+  /**
+   * Exports feature and connectivity information about provided circuits in a telecom domain network
+   * into JSON files for consumption by external systems. Each circuit exported is output to a separate JSON file.
+   *
+   * @param props - An object specifying configuration settings for the export.
+   * @returns Resolves to an object
+   *   specifying the export location and status for each circuit.
+   */
+  export(props: ExportCircuitsProps): Promise<CircuitExportResult[]>;
+  /**
+   * Returns a [Circuit](https://developers.arcgis.com/javascript/latest/api-reference/esri-networks-support-Circuit.html) instance
+   * with its `circuitManager` property set to the current `CircuitManager` instance.
+   *
+   * @param circuitName - The name of the `Circuit` instance to create.
+   * @param isSectioned - = false - Whether the `Circuit` instance is sectioned.
+   * @returns A `Circuit` instance with its `circuitManager` property set to the current `CircuitManager` instance.
+   */
+  getCircuit(circuitName: string, isSectioned?: boolean): Circuit;
+  /**
+   * Loads the telecom domain network's circuit section table.
+   *
+   * @returns Resolves to a loaded [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the circuit section table.
+   */
+  loadCircuitSectionTable(): Promise<FeatureLayer>;
+  /**
+   * Loads the telecom domain network's circuit table.
+   *
+   * @returns Resolves to a loaded [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the circuit table.
+   */
+  loadCircuitTable(): Promise<FeatureLayer>;
+  /**
+   * Loads the telecom domain network's subcircuit table.
+   *
+   * @returns Resolves to a loaded [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html) for the subcircuit table.
+   */
+  loadSubcircuitTable(): Promise<FeatureLayer>;
+  /**
+   * Returns the names of circuits in a telecom domain network with specified start/stop locations.
+   *
+   * @param props - The start/stop location of the circuits to query.
+   * @returns The queried circuit names.
+   */
+  queryCircuitNames(props: QueryCircuitProps): Promise<string[]>;
+  /**
+   * Returns circuits from a telecom domain network that satisfy a specified query.
+   * This method accepts two types of input: an array of circuit names, or an object specifying a trace location from
+   * which the circuits to query either start or stop.
+   *
+   * If specifying a trace location: If `returnConsumingCircuits` is false, only the immediate circuits that pass
+   * through the specified feature are returned. Otherwise, all the circuits that consume the immediate circuits are returned.
+   *
+   * @param input - The names or start/stop location of the circuits to query.
+   * @returns The queried circuits.
+   */
+  queryCircuits(input: string[] | QueryCircuitProps): Promise<Circuit[]>;
+  /**
+   * Checks the validity of circuits in a telecom domain network.
+   * The operation confirms that a circuit can be traced from the starting location to the stopping location
+   * and ensures that circuit sections and subcircuits are properly configured.
+   *
+   * @param circuitNames - The names of the circuit or circuits to be verified.
+   * @param synthesizeGeometries - = false - Specifies whether geometries will be inferred and created (synthesized) for the circuits.
+   * @returns Resolves to an array of objects
+   *   specifying the verification status for each circuit.
+   */
+  verify(circuitNames: string[], synthesizeGeometries?: boolean): Promise<CircuitVerifyResult[]>;
+}