@conterra/ct-mapapps-typings 4.12.1 → 4.13.0-next.20211203074743

package/agssearch/AGSSearchInterpreter.d.ts

@@ -1,5 +1,4 @@
-export default AGSSearchInterpreter;
-declare class AGSSearchInterpreter {
+export class AGSSearchInterpreter {
     interpret(configFragment: any): Promise<{
         apply: () => void;
         dispose: () => void;

package/agssearch/AGSSearchMerger.d.ts

@@ -1,4 +1,4 @@
-export default function _default(storeFactory: any, bundleContext: any, configuration: any): {
+export function AGSSearchMerger(storeFactory: any, bundleContext: any, configuration: any): {
     apply: () => void;
     dispose: () => void;
 };

package/agssearch/AGSStoreFactory.d.ts

@@ -1,6 +1,27 @@
-export default AGSStoreFactory;
-declare function AGSStoreFactory(): {
-    createStore(options: any): MapServerLayerStore;
+/**
+ * Factory class that creates store instances.
+ */
+export class AGSStoreFactory {
+    /**
+     * Creates a new store instance backed by an ArcGIS Feature Server or Map Server.
+     * Either the `layerId` parameter or the `url` parameter must be specified.
+     *
+     * @param {Object} options
+     * @param {string} [options.id] The id of the new store
+     * @param {string} [options.layerId] A valid layer or sublayer id
+     * @param {string} [options.url] A service url, for services that are not in the map
+     * @param {boolean} [options.legacyImplementation]
+     *      Set this value to `true` to use the deprecated old MapServerLayerStore implementation
+     *      instead of the new LayerStore.
+     * @returns A promise that resolves to the new store instance
+     */
+    createStore(options: {
+        id?: string | undefined;
+        layerId?: string | undefined;
+        url?: string | undefined;
+        legacyImplementation?: boolean | undefined;
+    }): Promise<LayerStore | MapServerLayerStore>;
     _getServiceInfoFromMap(layerId: any): any;
-};
+}
+import { LayerStore } from "./LayerStore";
 import MapServerLayerStore from "ct/mapping/store/MapServerLayerStore";

package/agssearch/AutoStoreRegistration.d.ts

@@ -1,10 +1,11 @@
-export default class AutoStoreRegistration {
+export class AutoStoreRegistration {
     _observers: import("apprt-core/Observers").Observers;
     _storeRegistrations: Map<any, any>;
     _storeRegistrationTasks: Map<any, any>;
     activate(componentContext: any): void;
     _bundleContext: any;
     _delay: any;
+    _useLegacyImplementation: any;
     _observeMap(): void;
     _observeLayer(layer: any, callback: any): {
         remove: () => void;
@@ -13,7 +14,7 @@ export default class AutoStoreRegistration {
     _observeServiceLayer(rootLayer: any, id: any): void;
     _checkSublayer(layer: any, id: any): void;
     _delayedRegisterStoreFrom(layer: any, id: any): void;
-    _registerStoreFrom(layer: any, id: any): void;
+    _registerStoreFrom(layer: any, id: any): Promise<void>;
     _delayedUnregisterStoreOf(layer: any, id: any): void;
     _unregisterStoreOf(rootLayer: any): void;
     deactivate(): void;

package/agssearch/FilterStoreFactory.d.ts

@@ -1,5 +1,4 @@
-export default FilterStoreFactory;
-declare function FilterStoreFactory(): {
+export function FilterStoreFactory(): {
     activate(): void;
     _initStore(): any;
     _logError(id: any, error: any): any;
@@ -16,5 +15,5 @@ declare function FilterStoreFactory(): {
     _checkStoreRegistrationStateAsync(targetLayer: any): void;
     _checkStoreRegistrationState(targetLayer: any): void;
     deactivate(): void;
-    _register(store: any, props: any): void;
+    _register(store: any, props: any, targetLayer: any, nonFilteredStore: any): void;
 };

package/agssearch/LayerStore.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="arcgis-js-api" />
+import type FeatureLayer from "esri/layers/FeatureLayer";
+import type Sublayer from "esri/layers/support/Sublayer";
+import type Map from "esri/Map";
+import type { ComplexQueryExpression } from "store-api/api/ComplexQueryLang";
+import type { AsyncStore, GetOptions, Metadata, QueryOptions, AsyncQueryResult } from "store-api/api/Store";
+export interface LayerStoreMetadata extends Metadata {
+    /** The feature id property name. Same as store.idProperty. */
+    readonly idProperty: string;
+    /** Whether the store supports pagination or not. */
+    readonly supportsPagination: boolean;
+    /** Maximum number of features that can be requested from the server. */
+    readonly maxRecordCount: number;
+}
+declare type FeatureLayerProps = "type" | "destroy" | "load" | "loaded" | "capabilities" | "sourceJSON" | "objectIdField" | "title" | "displayField" | "geometryType" | "fullExtent" | "popupTemplate" | "fields" | "createQuery" | "queryObjectIds" | "queryFeatures" | "queryFeatureCount";
+export declare type SimpleFeatureLayer = Pick<FeatureLayer, FeatureLayerProps>;
+declare type Feature = Record<string, any>;
+declare type FeatureId = string | number;
+/**
+ * A store implementation that searches directly on an ArcGIS Feature Layer object.
+ */
+export declare class LayerStore implements AsyncStore<Feature, FeatureId> {
+    #private;
+    readonly id: undefined;
+    readonly idProperty: undefined;
+    private constructor();
+    /**
+     * Creates a new store instance for the given layer path.
+     * The layer (or sublayer) must exist in the map.
+     * Currently only feature layers and sublayers of map image layers are supported.
+     */
+    static forLayerPath(id: string | undefined, layerPath: string, map: Map): Promise<LayerStore>;
+    /**
+     * Creates a new store instance that searches on the provided feature layer.
+     *
+     * @param id the store's id (optional)
+     * @param layer the feature layer to use as a data source
+     */
+    static forFeatureLayer(id: string | undefined, layer: SimpleFeatureLayer): LayerStore;
+    /**
+     * Creates a new store instance that searches on the provided sublayer of a map image layer.
+     *
+     * @param id the store's id (optional).
+     * @param sublayer the sublayer to use as a data source
+     */
+    static forMapImageSublayer(id: string | undefined, sublayer: Sublayer): Promise<LayerStore>;
+    destroy(): void;
+    load(): Promise<void>;
+    getMetadata(): Promise<LayerStoreMetadata>;
+    getIdentity(feature: Feature): string | number;
+    query(query?: ComplexQueryExpression, options?: QueryOptions): AsyncQueryResult<Feature>;
+    get(id: FeatureId, options?: GetOptions): Promise<Feature | undefined>;
+}
+export {};

package/agssearch/StoreInitializer.d.ts

@@ -1,8 +1,7 @@
-export default StoreInitializer;
-declare function StoreInitializer(opts: any): {
-    init(props: any): Promise<{
+export function StoreInitializer(opts: any): {
+    init(props: any): globalThis.Promise<{
         store: any;
+        nonFilteredStore: any;
         props: any;
     }>;
 };
-import Promise from "apprt-core/Promise";

package/agssearch/module.d.ts

@@ -1 +1,4 @@
-export {};
+export { AGSStoreFactory } from "./AGSStoreFactory";
+export { FilterStoreFactory as AGSStore } from "./FilterStoreFactory";
+export { AutoStoreRegistration } from "./AutoStoreRegistration";
+export { AGSSearchInterpreter } from "./AGSSearchInterpreter";

package/agssearch/util.d.ts

@@ -1,4 +1,4 @@
 export function parseLayerPath(layerPath: any): {
-    layerId: any;
-    subLayerId: any;
+    layerId: string | undefined;
+    subLayerId: string | undefined;
 } | undefined;

package/agssearch-config/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "agssearch-config",
+    "dependencies": {},
+    "types": "./main.d.ts"
+}

package/apprt/event/Event.d.ts

@@ -48,7 +48,7 @@ export default class TopicEvent {
     /**
      * @returns The string representation of this event.
      */
-    toString(): any;
+    toString(): string;
     #private;
 }
 /**

package/apprt/test-data/i18n-bundles/system/main.d.ts

@@ -1 +1 @@
-export const _null: any;
+export const _null: null;

package/apprt-core/deprecate.d.ts

@@ -12,5 +12,5 @@
  * @param name Class or function that will be deprecated
  * @param description A short description which class or function shall be used instead
  */
-declare function deprecate(name: string, description: string): void;
+export declare function deprecate(name: string, description: string): void;
 export default deprecate;

package/apprt-streams/Stream.d.ts

@@ -38,22 +38,63 @@ export declare abstract class Stream<T> implements Iterable<T> {
     /**
      * Generates [index, value] tuples where value is from the original iterable
      * and index is the index of the current value.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     *
+     * const result = Stream.enumerate(["a", "b"]).toArray(); // [[0, "a"], [1, "b"]]
+     * ```
      */
     static enumerate<U>(iterable: Iterable<U>): Stream<[index: number, value: U]>;
     /**
      * Generates a stream by repeatedly invoking the provided `supplier` function.
+     * The returned stream is endless by default, use stop condition like `take()` or `takeWhile()` to limit the stream.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     *
+     * let nextValue = 1;
+     * function generateNumbers() {
+     *      return nextValue++;
+     * }
+     *
+     * const items = Stream.generate(generateNumbers).take(4).toArray(); // [1, 2, 3, 4]
+     * ```
      */
     static generate<U>(supplier: () => U): Stream<U>;
     /**
      * Creates a stream that iterates over the keys of the given object.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const input = { a: 1, b: 2};
+     * const output = Stream.keys(input).map((k) => k + k).toArray(); // ["aa", "bb"] (order might differ)
+     * ```
      */
     static keys<K extends string, U>(object: Record<K, U>): Stream<K>;
     /**
      * Creates a stream that iterates over the values of the given object.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const input = { a: 1, b: 2};
+     * const output = Stream.values(input).map((v) => v * 2).toArray(); // [2, 4] (order might differ)
+     * ```
      */
     static values<K extends string, U>(object: Record<K, U>): Stream<U>;
     /**
      * Creates a stream that iterates over the [key, value] pairs of the given object.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const input = { a: 1, b: 2};
+     * const output = Stream.entries(input).map((e) => `${e[0]}${e[1]}`).toArray(); // ["a1", "b2"] (order might differ)
+     * ```
      */
     static entries<K extends string, U>(object: Record<K, U>): Stream<[key: K, value: U]>;
     /**
@@ -65,6 +106,8 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * import { Stream } from "apprt-streams/Stream";
      * const numbers = Stream.integers(3).toArray(); // [0, 1, 2]
      * ```
+     *
+     * @param count the number of integers to produce
      */
     static integers(count: number): Stream<number>;
     /**
@@ -76,6 +119,9 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * import { Stream } from "apprt-streams/Stream";
      * const numbers = Stream.integers(3, 4).toArray(); // [3, 4, 5, 6]
      * ```
+     *
+     * @param start the start value
+     * @param count the number of integers to produce
      */
     static integers(start: number, count: number): Stream<number>;
     /**
@@ -110,7 +156,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * import { Stream } from "apprt-streams/Stream";
      * const left = [1, 2];
      * const right = ["a", "b", "c"];
-     * const zipped = Stream.zipLongest(left, right).toArray(); // [[1, "a"], [2, "b"]]
+     * const zipped = Stream.zip(left, right).toArray(); // [[1, "a"], [2, "b"]]
      * ```
      */
     static zip<Ts extends Iterable<any>[] | [Iterable<any>]>(...iterables: Ts): Stream<ZipValue<Ts>>;
@@ -140,6 +186,9 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * const items = [1, -2, 3];
      * const result = Stream.from(items).filter(n => n > 0).toArray(); // [1, 3]
      * ```
+     *
+     * @param predicate
+     *  A function that returns `true` if the item should be part of the returned stream.
      */
     filter<U extends T>(predicate: (item: T) => item is U): Stream<U>;
     filter(predicate: (item: T) => boolean): Stream<T>;
@@ -152,6 +201,9 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * const items = [1, 2];
      * const result = Stream.from(items).map(n => n + 1).toArray(); // [2, 3]
      * ```
+     *
+     * @param transform
+     *  A function that maps each item to a another item of an arbitrary type.
      */
     map<U>(transform: (item: T) => U): Stream<U>;
     /**
@@ -166,6 +218,10 @@ export declare abstract class Stream<T> implements Iterable<T> {
      *      (person) => person.age >= 18 ? person.age : undefined
      * ).toArray(); // [18, 21]
      * ```
+     *
+     * @param transform
+     *  A function that maps each item to a nullable item of an arbitrary type.
+     *  Return values `null` and `undefined` will be skipped in the returned stream.
      */
     filterMap<U>(transform: (item: T) => U | null | undefined): Stream<NonNullable<U>>;
     /**
@@ -189,6 +245,8 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * const items = [1, 2, 3];
      * const result = Stream.from(items).skip(1).toArray(); // [2, 3]
      * ```
+     *
+     * @param count the number of items to skip
      */
     skip(count: number): Stream<T>;
     /**
@@ -234,6 +292,8 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * const items = ["a", "b"];
      * const repeated = Stream.from(items).repeat(2).toArray(); // ["a", "b", "a", "b"];
      * ```
+     *
+     * @param count the number of repetitions
      */
     repeat(count: number): Stream<T>;
     /**
@@ -248,10 +308,10 @@ export declare abstract class Stream<T> implements Iterable<T> {
      */
     cycle(): Stream<T>;
     /**
-     * Returns a stream over the original items grouped into chunks of size `count`.
-     * Up to `count` consecutive elements will be gathered into an array and then returned by the stream.
+     * Returns a stream over the original items grouped into chunks of size `chunkSize`.
+     * Up to `chunkSize` consecutive elements will be gathered into an array and then returned by the stream.
      *
-     * All arrays, except for the last one, will be of length `count`. No array will be empty.
+     * All arrays, except for the last one, will be of length `chunkSize`. No array will be empty.
      *
      * @example
      * ```js
@@ -259,8 +319,10 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * const items = [1, 2, 3, 4, 5];
      * const chunked = Stream.from(items).chunk(3).toArray(); // [[1, 2, 3], [4, 5]]
      * ```
+     *
+     * @param chunkSize the maximum chunk size
      */
-    chunk(count: number): Stream<T[]>;
+    chunk(chunkSize: number): Stream<T[]>;
     /**
      * Chains the given iterables after `this` (see static `concat` function for details).
      */
@@ -307,6 +369,21 @@ export declare abstract class Stream<T> implements Iterable<T> {
     groupBy<U>(keyFunc: (item: T) => U): Stream<[U, T[]]>;
     /**
      * Returns a stream that groups adjacent elements for which the predicate returns true into arrays.
+     *
+     * This is different from `groupBy` because it allows arbitrary conditions for grouping.
+     * However, only elements next to each other can belong to a group.
+     * A new group is started whenever an element is encountered that does not belong to the current group.
+     *
+     * @example
+     * ```js
+     * const numbers = [1, 2, 4, 3, 0];
+     * const grouped = Stream.from(numbers)
+     *     .groupAdjacent((l, r) => Math.abs(l - r) <= 1) // close items belong to the same group
+     *     .toArray(); // [[1, 2], [4, 3], [0]]
+     * ```
+     *
+     * @param predicate
+     *  A function that returns true if `left` and `right` belong to the same group.
      */
     groupAdjacent(predicate: (left: T, right: T) => boolean): Stream<T[]>;
     /**
@@ -318,6 +395,12 @@ export declare abstract class Stream<T> implements Iterable<T> {
      *
      * NOTE: This function reads the entire stream into memory and stores all elements in an array
      * in order to sort it. This may be inefficient for very large datasets.
+     *
+     * @param compareFunc
+     *  Given two elements `left` and `right`, returns `< 0` if `left < right`, `> 0` if `right > left`
+     *  and `0` otherwise.
+     *  When not specified, elements are compared using standard `<` and `>` (which might be useless,
+     *  e.g. when keys are objects or arrays).
      */
     sort(compareFunc?: (left: T, right: T) => number): Stream<T>;
     /**
@@ -326,8 +409,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * NOTE: This function reads the entire stream into memory and stores all elements in an array
      * in order to sort it. This may be inefficient for very large datasets.
      *
-     * Example:
-     *
+     * @example
      * ```js
      * const items = [
      *     { name: "A", age: 18 },
@@ -357,8 +439,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * NOTE: This function reads the entire stream into memory and stores all elements in a Set
      * for de-duplication. This may be inefficient for very large datasets.
      *
-     * Example:
-     *
+     * @example
      * ```js
      * const items = [
      *     {age: 1},
@@ -378,6 +459,11 @@ export declare abstract class Stream<T> implements Iterable<T> {
      *
      * NOTE: This function reads the entire stream into memory in order to reverse the item order.
      * This may be inefficient for very large datasets.
+     *
+     * @example
+     * ```js
+     * const items = Stream.integers(4).reverse().toArray(); // [3, 2, 1, 0]
+     * ```
      */
     reverse(): Stream<T>;
     /**
@@ -414,6 +500,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * Joins all elements of this stream together into a string.
      * Individual elements will converted to string (via `String(elements)`)
      * and separated by `separator`.
+     *
      * @param separator The separator to use between two elements. Defaults to `","`.
      */
     join(separator?: string): string;
@@ -425,21 +512,49 @@ export declare abstract class Stream<T> implements Iterable<T> {
     count(): number;
     /**
      * Gathers all elements of this stream into an array.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const array = Stream.integers(3).toSet(); // [0, 1, 2]
+     * ```
      */
     toArray(): T[];
     /**
      * Gathers all elements of this stream into an object.
      * The elements must be [key, value] pairs, and the keys must be
      * strings, symbols or numbers.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const object = Stream.from(["a", "b", "c"])
+     *      .map((v) => [v, v + "!"])
+     *      .toObject(); // { a: "a!", b: "b!", c: "c!"}
+     * ```
      */
     toObject(this: T extends [PropertyKey, any] ? this : never): T extends [infer K, infer V] ? (K extends PropertyKey ? Record<K, V> : never) : never;
     /**
      * Gathers all elements of this stream into a set.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const set = Stream.integers(3).toSet(); // set of 0, 1, 2
+     * ```
      */
     toSet(): Set<T>;
     /**
      * Gathers the elements of this stream into a map.
      * The elements must be [key, value] pairs.
+     *
+     * @example
+     * ```js
+     * import { Stream } from "apprt-streams/Stream";
+     * const map = Stream.from(["a", "b", "c"])
+     *      .map((v) => [v, v + "!"])
+     *      .toMap(); // // a -> a!, b -> b!, c -> c!
+     * ```
      */
     toMap(this: T extends [any, any] ? this : never): T extends [infer K, infer V] ? Map<K, V> : never;
     /**

package/{map-init → banner-config}/package.json

@@ -1,5 +1,5 @@
 {
-    "name": "map-init",
+    "name": "banner-config",
     "dependencies": {},
     "types": "./main.d.ts"
 }

package/console/BundleActions.d.ts

@@ -1,5 +1,5 @@
 export default class BundleActions {
-    dataViewModel: any;
+    dataViewModel: null;
     stopBundle(): void;
     startBundle(): void;
     _withSelectedBundles(cb: any): void;

package/console/ComponentsStore.d.ts

@@ -2,7 +2,7 @@
  * A components store, for searching of components.
  */
 export default class ComponentsStore extends _BaseStore {
-    _cpRuntime: any;
+    _cpRuntime: null;
     _getRawItemById(id: any): any;
     _getRawItems(): any;
     _createItem(component: any): {

package/console/EnableToolOnSelectionChanged.d.ts

@@ -1,7 +1,7 @@
 declare const EnableToolOnSelectionChanged_base: any;
 export default class EnableToolOnSelectionChanged extends EnableToolOnSelectionChanged_base {
     [x: string]: any;
-    dataViewModel: any;
+    dataViewModel: null;
     activate(): void;
     deactivate(): void;
     _refreshToolState(name: any, oldValue: any, selectedIds: any): void;

package/console/MessagesStore.d.ts

@@ -1,5 +1,5 @@
 export default class MessagesStore extends _BaseStore {
-    _logger: any;
+    _logger: null;
     _getRawItemById(id: any): any;
     _getRawItems(): any;
     _createItem(entry: any, index: any): {

package/console/ServicesStore.d.ts

@@ -1,5 +1,5 @@
 export default class ServicesStore extends _BaseStore {
-    _cpRuntime: any;
+    _cpRuntime: null;
     _getRawItemById(id: any): any;
     _getRawItems(): any;
     _createItem(serviceReference: any): {

package/console/_BaseStore.d.ts

@@ -1,8 +1,8 @@
 export default class _BaseStore {
     constructor(opts: any);
     idProperty: string;
-    metadata: any;
-    getMetadata(): any;
+    metadata: null;
+    getMetadata(): null;
     getIdentity(obj: any): any;
     get(id: any): any;
     query(query: any, options: any): import("../../search/store-api/api/Store").ResultItems<Readonly<Record<string, any>>>;

package/coordinateconversion/WGSConverter.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="arcgis-js-api" />
 export default function WGSConverter(i18n: any): {
     pointToDmsString(point: any): string;
     dmsStringToPoint(string: any): Point;
     pointToDdString(point: any, decimalPlaces: any): string;
     ddStringToPoint(string: any): Point;
 };
-import Point from "esri/geometry/Point";

package/coordinateviewer/Config.d.ts

@@ -1,5 +1,4 @@
-export default Config;
-declare function Config(): {
+export default function Config(): {
     createInstance(): import("../../../apprt/apprt-core/Mutable").Mutable<{
         scale: undefined;
         scalePrefix: string | undefined;

package/coordinateviewer/Converters.d.ts

@@ -2,4 +2,3 @@ export function coordinateTransformationConverter(transformer: any, targetEPSGCo
 export function srsTitleConverter(transformer: any): (coord: any) => Promise<any>;
 export function degreeFormatConverter(transformer: any, latLonOptions: any): (coord: any) => Promise<any>;
 export function chainConverters(converters: any): (coord: any) => Promise<any>;
-import Promise from "apprt-core/Promise";

package/custominfo-config/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "custominfo-config",
+    "dependencies": {},
+    "types": "./main.d.ts"
+}

package/graphics/GraphicsBuilder.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="arcgis-js-api" />
 export default GraphicsBuilder;
 declare function GraphicsBuilder(): {
     createGraphic: ({ geometry, symbolLookupStrategy, context, attributes }: {
@@ -8,4 +7,3 @@ declare function GraphicsBuilder(): {
         attributes: any;
     }) => Graphic;
 };
-import Graphic from "esri/Graphic";

package/highlights/api.d.ts

@@ -65,6 +65,12 @@ export interface HighlightGraphic extends Partial<Graphic> {
      * the view is in "3D" mode at the time of creation.
      */
     symbol3D?: esriSymbol;
+    /**
+     * Template for maptips.
+     *
+     * Requires maptip bundle.
+     */
+    maptipTemplate?: any;
 }
 /**
  * 2D or 3D view mode.

package/integration-map/GeometryHighlighter.d.ts

@@ -0,0 +1,8 @@
+import { Highlighter } from "highlights/api";
+export declare class GeometryHighlighter {
+    private highlighter;
+    private currentHighlight?;
+    constructor(highlighter: Highlighter);
+    highlight(esriGeomOrGraphic: any): void;
+    clearHighlight(): void;
+}