@conterra/ct-mapapps-typings 4.18.4-next.20241007040658 → 4.18.4-next.20241009040310

package/apprt-dom/index.d.ts

@@ -83,7 +83,7 @@ type HTMLElementForTag<Tag extends ElementTag> = HTMLElementTagNameMap[Tag];
  * Creates a new HTML node with the given tag.
  *
  * For example, to create new div and insert it as the last element of `parent`:
- * ```js
+ * ```ts
  * import { createElement } from "apprt-dom";
  * const parent = document.body;
  * const node = createElement("div", {
@@ -101,14 +101,14 @@ declare function createElement(tagName: string, options?: CreateOptions): HTMLEl
  * Inserts a node at the specified position relative to a another node.
  *
  * For example, to insert a node as the last element of `parent`:
- * ```js
- *  import { insertElement } from "apprt-dom";
- *  const node = ...;
- *  const parent = document.body;
- *  insertElement(node, {
+ * ```ts
+ * import { insertElement } from "apprt-dom";
+ * const node = ...;
+ * const parent = document.body;
+ * insertElement(node, {
  *     referenceNode: parent,
  *     position: "last"
- *  });
+ * });
  * ```
  * @param node a html node
  * @param options the position options

package/apprt-fetch/index.d.ts

@@ -4,16 +4,16 @@ import { DeepReadonly } from 'apprt-core/Types';
  * Exports some default content types as optional utilities.
  *
  * @example use JSON content type in request headers
- * ```js
- *    import { apprtFetch, ContentType } from "apprt-fetch";
+ * ```ts
+ *  import { apprtFetch, ContentType } from "apprt-fetch";
  *
- *    apprtFetch(url, {
- *          method: "POST",
- *          headers: {
- *              "Content-Type": ContentType.JSON_UTF8
- *              "Accept": ContentType.JSON
- *          }
- *     });
+ * apprtFetch(url, {
+ *     method: "POST",
+ *     headers: {
+ *         "Content-Type": ContentType.JSON_UTF8,
+ *         "Accept": ContentType.JSON
+ *     }
+ * });
  * ```
  */
 declare enum ContentType {
@@ -63,7 +63,7 @@ declare enum ContentType {
  * Provides a wrapper around the browsers `fetch` API.
  *
  * @example Fetch a json file
- * ```js
+ * ```ts
  * import { apprtFetch, ContentType} from "apprt-fetch";
  *
  * // execute a get request
@@ -82,7 +82,7 @@ declare enum ContentType {
  * const data = await response.json();
  * ```
  * @example Fetch a json file with apprtFetchJson
- * ```js
+ * ```ts
  * import { apprtFetchJson } from "apprt-fetch";
  *
  * // execute a get request
@@ -93,7 +93,7 @@ declare enum ContentType {
  * ```
  *
  * @example POST x-www-form-urlencoded content
- * ```js
+ * ```ts
  * import { apprtFetch, ContentType } from "apprt-fetch";
  *
  * // execute a POST request
@@ -117,7 +117,7 @@ declare enum ContentType {
  * ```
  *
  * @example POST x-www-form-urlencoded content with flag queryTransport:'form'
- * ```js
+ * ```ts
  * import { apprtFetch, ContentType } from "apprt-fetch";
  *
  * // execute a POST request
@@ -133,7 +133,7 @@ declare enum ContentType {
  *     },
  *
  *     // normally this would stay url parameters ?f=json
- *     query: { f: "json" }
+ *     query: { f: "json" },
  *
  *     // but this flags converts the query to the body
  *     queryTransport: "form"
@@ -143,7 +143,7 @@ declare enum ContentType {
  * const data = await response.json();
  * ```
  * @example POST application/json content
- * ```js
+ * ```ts
  * import { apprtFetch, ContentType } from "apprt-fetch";
  *
  * // execute a POST request
@@ -443,7 +443,7 @@ declare function getConfig(): Config;
  *
  * Basic usage:
  *
- * ```js
+ * ```ts
  * import { apprtFetch } from "apprt-fetch";
  * const response = await apprtFetch("https://httpbin.org/get");
  * if (!response.ok) {
@@ -464,7 +464,7 @@ declare function apprtFetch(target: ApprtRequestTarget, init?: ApprtRequestInit)
  *
  * Basic usage:
  *
- * ```js
+ * ```ts
  * import { apprtFetchJson } from "apprt-fetch";
  * const jsonData = await apprtFetchJson("https://httpbin.org/get");
  * // do something with the json data

package/apprt-streams/Stream.d.ts

@@ -23,7 +23,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * be iterated multiple times (some iterables, like generators, do not support repeated iteration).
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * Stream.from([]);             // Wraps any iterable
      * Stream.from(Stream.empty()); // Returns original stream for stream arguments
@@ -35,7 +35,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Creates a new, empty stream.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * Stream.empty().count(); // 0
      * ```
@@ -50,7 +50,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * and index is the index of the current value.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      *
      * const result = Stream.enumerate(["a", "b"]).toArray(); // [[0, "a"], [1, "b"]]
@@ -63,7 +63,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * for example `take()`, or break in a `for...of` loop.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      *
      * let nextValue = 1;
@@ -79,7 +79,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Creates a stream that iterates over the keys of the given object.
      *
      * @example
-     * ```js
+     * ```ts
      * 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)
@@ -90,7 +90,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Creates a stream that iterates over the values of the given object.
      *
      * @example
-     * ```js
+     * ```ts
      * 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)
@@ -101,7 +101,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Creates a stream that iterates over the [key, value] pairs of the given object.
      *
      * @example
-     * ```js
+     * ```ts
      * 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)
@@ -113,7 +113,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * In other words, this produces the interval `[0, 1, ..., count)`.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const numbers = Stream.integers(3).toArray(); // [0, 1, 2]
      * ```
@@ -126,7 +126,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * In other words, this produces the interval `[start +0, start +1, ..., start +count)`.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const numbers = Stream.integers(3, 4).toArray(); // [3, 4, 5, 6]
      * ```
@@ -142,7 +142,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * or break in a `for...of` loop.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const numbers = Stream.allIntegers().take(3).toArray(); // [0, 1, 2]
      * ```
@@ -154,7 +154,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Creates a new stream by chaining the given iterables after each other.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const result = Stream.concat([1], [2]).toArray(); // [1, 2]
      * ```
@@ -169,7 +169,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * The stream stops when the shortest of the given iterables has ended.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const left = [1, 2];
      * const right = ["a", "b", "c"];
@@ -187,7 +187,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * are exhausted, their tuple items are set to undefined.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const left = [1, 2];
      * const right = ["a", "b", "c"];
@@ -209,7 +209,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * returns true will be produced by the stream.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, -2, 3];
      * const result = Stream.from(items).filter(n => n > 0).toArray(); // [1, 3]
@@ -224,7 +224,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Returns a stream that maps all elements of the input by using the provided `transform` function.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2];
      * const result = Stream.from(items).map(n => n + 1).toArray(); // [2, 3]
@@ -239,7 +239,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * then discards all items that are `null` or `undefined`.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const persons = [{ age: 7 }, { age: 18 }, { age: 21 }];
      * const adultAges = Stream.from(persons).filterMap(
@@ -257,7 +257,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * multiple elements of the new stream).
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [[1], [2, 3]];
      * const result = Stream.from(items).flat().toArray(); // [1, 2, 3]
@@ -268,7 +268,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Returns a stream that skips the first `count` elements of its input.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2, 3];
      * const result = Stream.from(items).skip(1).toArray(); // [2, 3]
@@ -283,7 +283,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * in the returned stream.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2, 3, 4, -1, -2, -3];
      * const result = Stream.from(items).skipWhile((n) => n < 4).toArray(); // [4, -1, -2, -3]
@@ -298,7 +298,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Returns a stream that limits the input to at most `count` elements.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2, 3];
      * const result = Stream.from(items).take(1).toArray(); // [1]
@@ -313,7 +313,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * for the first time.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2, 3, 4, -1, -2, -3];
      * const result = Stream.from(items).takeWhile((n) => n < 4).toArray(); // [1, 2, 3]
@@ -327,7 +327,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Returns a stream that repeats its contents `count` times.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = ["a", "b"];
      * const repeated = Stream.from(items).repeat(2).toArray(); // ["a", "b", "a", "b"];
@@ -342,7 +342,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * in a `for...of` loop.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2];
      * const cycled = Stream.from(items).cycle().take(5).toArray(); // [1, 2, 1, 2, 1]
@@ -357,7 +357,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * All arrays, except for the last one, will be of length `chunkSize`.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const items = [1, 2, 3, 4, 5];
      * const chunked = Stream.from(items).chunk(3).toArray(); // [[1, 2, 3], [4, 5]]
@@ -397,7 +397,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * items in an internal map, which may be inefficient for very large datasets.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const persons = [
      *     { name: "A", age: 18 },
@@ -422,7 +422,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * A new group is started whenever an element is encountered that does not belong to the current group.
      *
      * @example
-     * ```js
+     * ```ts
      * 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
@@ -457,7 +457,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * to be able to sort it. This may be inefficient for very large datasets.
      *
      * @example
-     * ```js
+     * ```ts
      * const items = [
      *     { name: "A", age: 18 },
      *     { name: "B", age: 28 },
@@ -487,7 +487,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * for de-duplication. This may be inefficient for very large datasets.
      *
      * @example
-     * ```js
+     * ```ts
      * const items = [
      *     {age: 1},
      *     {age: 2},
@@ -511,7 +511,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * This may be inefficient for very large datasets.
      *
      * @example
-     * ```js
+     * ```ts
      * const items = Stream.integers(4).reverse().toArray(); // [3, 2, 1, 0]
      * ```
      */
@@ -626,7 +626,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Gathers all elements of this stream into an array.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const array = Stream.integers(3).toArray(); // [0, 1, 2]
      * ```
@@ -638,7 +638,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * strings, symbols or numbers.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const object = Stream.from(["a", "b", "c"])
      *      .map((v) => [v, v + "!"])
@@ -653,7 +653,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Iterating over the set will yield the same order because sets maintain their insertion order.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const set = Stream.integers(3).toSet(); // set of 0, 1, 2
      * ```
@@ -667,7 +667,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      * Iterating over the map will yield the same order because maps maintain their insertion order.
      *
      * @example
-     * ```js
+     * ```ts
      * import { Stream } from "apprt-streams/Stream";
      * const map = Stream.from(["a", "b", "c"])
      *      .map((v) => [v, v + "!"])
@@ -680,7 +680,7 @@ declare abstract class Stream<T> implements Iterable<T> {
      *
      * @example
      *
-     * ```js
+     * ```ts
      * for (const value of Stream.integers(5)) {
      *     console.info(value);
      * }

package/coordinatetransformer/api/CoordinateTransformer.d.ts

@@ -15,7 +15,7 @@ interface Coordinates {
  *
  * @example Sample for different input variants
  *
- * ```js
+ * ```ts
  * const wgs84String = "EPSG:4326";
  * const wgs84Wkid   = 4326;
  *
@@ -71,22 +71,27 @@ type CoordinateModificationCallback = (input: Readonly<Coordinates>) => Coordina
  * "components": [{
  *   "name": "MyComponent",
  *   "references": [{
- *      "name": "_coordinateTransformer",
+ *      "name": "coordinateTransformer",
  *      "providing": "coordinatetransformer.CoordinateTransformer"
  *    }]
  * }]
  * ```
  *
- * In your code (MyComponent.js):
+ * In your code (MyComponent.ts):
+ *
+ * ```ts
+ * import { InjectedReference } from "apprt-core/InjectedReference";
+ * import { CoordinateTransformer } from "coordinatetransformer/CoordinateTransformer";
+ * import { Geometry } from "esri/geometry";
  *
- * ```js
  * export default class MyComponent {
- *   async transformToWGS84(geometry){
- *      const wgs84Code = 4326;
- *      const transformedGeometry =
- *              await this._coordinateTransformer.transform(geometry, wgs84Code);
- *      return transformedGeometry;
- *   }
+ *     private coordinateTransformer: InjectedReference<CoordinateTransformer>;
+ *     async transformToWGS84(geometry: Geometry): Promise<Geometry> {
+ *         const wgs84Code = 4326;
+ *         const transformedGeometry =
+ *             await this.coordinateTransformer!.transform(geometry, wgs84Code);
+ *         return transformedGeometry;
+ *     }
  * }
  * ```
  */

package/coordinatetransformer/api/ProjectionStore.d.ts

@@ -37,12 +37,13 @@ import 'esri/geometry';
  *
  * In your code (MyComponent.js):
  *
- * ```js
- * export default class MyComponent {
- *   async findAvailableProjections(){
- *      const projections = await this._projectionsStore.query({});
- *      // ...
- *   }
+ * ```ts
+ * export class MyComponent {
+ *     private projectionStore: InjectedReference<ProjectionStore>;
+ *     async findAvailableProjections(): Promise<ResultItems<Projection>> {
+ *         const projections = await this.projectionStore!.query({});
+ *         return projections;
+ *     }
  * }
  * ```
  */

package/coordinatetransformer/api/TransformationProvider.d.ts

@@ -21,11 +21,18 @@ import { Items } from './CoordinateTransformer.js';
  * }]
  * ```
  *
- * In your code (MyCustomTransformationProvider.js):
+ * In your code (MyCustomTransformationProvider.ts):
  *
- * ```js
- * export default class MyCustomTransformationProvider {
- *     transformationFor(sourceSRS, targetSRS) {
+ * ```ts
+ * export default class MyCustomTransformationProvider implements TransformationProvider
+ * {
+ *     transformationFor(
+ *         sourceSRS: SpatialReference,
+ *         targetSRS: SpatialReference
+ *     ):
+ *         | GeographicTransformation
+ *         | Items<Partial<GeographicTransformationStep>>
+ *         | undefined {
  *         // Pseudo code
  *         if (sourceSRS.wkid === 1234 && targetSRS.wkid === 4567) {
  *             return {

package/coordinatetransformer/api/TransformerStrategy.d.ts

@@ -17,12 +17,15 @@ import { Items } from './CoordinateTransformer.js';
  * }]
  * ```
  *
- * In your code (MyCustomTransformerStrategy.js):
+ * In your code (MyCustomTransformerStrategy.ts):
  *
- * ```js
- * export default class MyCustomTransformerStrategy {
- *     // the method is specified by the interface TransformerStrategy
- *     transform(geometry, sourceSRS, targetSRS) {
+ * ```ts
+ * export default class MyCustomTransformerStrategy implements TransformerStrategy {
+ *     transform(
+ *         geometry: Items<Geometry>,
+ *         sourceSRS: SpatialReference,
+ *         targetSRS: SpatialReference
+ *     ): Items<Geometry> | Promise<Items<Geometry>> {
  *         // pseudo code
  *         return transformation(sourceSRS, targetSRS).transform(geometry);
  *     }

package/ct/util/css.d.ts

@@ -31,8 +31,8 @@ declare class ExtendedPromise<T> implements Promise<T> {
      * Creates Promise instances.
      * @param executor defined as (resolve,reject)=> \{\}
      * @example
-     * ```js
-     * new Promise((resolve,reject)=>{
+     * ```ts
+     * new Promise((resolve, reject)=>{
      *      ...
      * });
      * ```
@@ -100,7 +100,7 @@ declare class ExtendedPromise<T> implements Promise<T> {
      * Allows to resolve/reject the promise manually after creating it.
      *
      * @example
-     * ```js
+     * ```ts
      * const { promise, resolve, reject } = Promise.withResolvers();
      * ```
      * @returns {{ promise, resolve, reject }}
@@ -203,14 +203,15 @@ declare class CancelablePromise<T> extends ExtendedPromise<T> {
      * Creates Promise instances with "cancel" function.
      * @param executor function defined as (resolve,reject,onCancelled)=> \{\}
      * @example
-     * ```js
-     * let p = new CancelablePromise((resolve,reject,onCancelled)=>{
-     *      onCancelled(()=> // do stuff if cancelled);
-     *      ...
+     * ```ts
+     * const p = new CancelablePromise((resolve, reject, onCancelled) => {
+     *     onCancelled(() => {
+     *         doSomething();
+     *     });
      * });
      *
      * // grab cancel function for later cancellation
-     * let cancel = p.cancel;
+     * const cancel = p.cancel;
      *
      * // now cancel
      * cancel();

package/domains-system/api.d.ts

@@ -18,38 +18,34 @@ import { Bundle } from 'apprt/api';
  *
  * @example
  *
- * ```js
- * export class MyInterpreter(){
+ * ```ts
+ * export class MyInterpreter implements ConfigFragmentInterpreter {
+ *     allInitialOrderedBundlesInterpreted(): void {}
  *
- *    allInitialOrderedBundlesInterpreted(){
- *    }
+ *     allInitialBundlesInterpreted(): void {}
  *
- *    allInitialBundlesInterpreted(){
- *    }
- *
- *    interpret(configFragment, options){
- *
- *        const myConfig = configFragment.getConfig("my-custom-key");
- *        if (!myConfig){
- *            // nothing to do
- *            return Promise.resolve();
- *        }
- *
- *        // interpret the config
- *        ...
- *        // e.g. create a resource
- *        const resource = ...;
- *
- *        // interpretation is finished
- *        return Promise.resolve({
- *            // this is called if the interpreted domain bundle is stopped
- *            dispose(){
- *                // ensure created resources are cleaned
- *                resource.cleanup();
- *            }
- *        });
- *
- *    }
+ *     async interpret(
+ *         configFragment: ConfigFragment,
+ *         options: InterpretationOptions
+ *     ): Promise<Disposable | void> {
+ *         const myConfig = configFragment.getConfig("my-custom-key");
+ *         if (!myConfig) {
+ *             // nothing to do
+ *             return Promise.resolve();
+ *         }
+ *         // interpret the config
+ *         ...
+ *         // e.g. create a resource
+ *         const resource = ...;
+ *         // interpretation is finished
+ *         return Promise.resolve({
+ *             // this is called if the interpreted domain bundle is stopped
+ *             dispose() {
+ *                 // ensure created resources are cleaned
+ *                 resource.cleanup();
+ *             }
+ *         });
+ *     }
  * }
  * ```
  */

package/highlights/api.d.ts

@@ -171,24 +171,19 @@ interface HighlighterFactory {
      * @param options additional options
      *
      * @example <caption>highlighter for mapwidget model</caption>
-     * ```js
+     * ```ts
      * // inject factory as `highlights.HighlighterFactory`
      * // inject model as `map-widget.MapWidgetModel`
-     * const highlighter = factory.forMapWidgetModel(model)
-     * highlighter.highlight({
-     *       geometry,
-     *       attributes,
-     *       symbol,
-     *       context
-     * });
+     * const highlighter = factory.forMapWidgetModel(model);
+     * highlighter.highlight(graphic);
      * // later clean up
      * highlighter.destroy();
      * ```
      *
      * @example <caption>highlighter using custom collection</caption>
-     * ```js
-     * const glayer = new GraphicsLayer();
-     * const graphics = glayer.graphics;
+     * ```ts
+     * const graphicsLayer = new GraphicsLayer();
+     * const graphics = graphicsLayer.graphics;
      * const highlighter = factory.forMapWidgetModel(model, { graphicsCollectionResolver: (model) => graphics });
      * // now highlights are added to the custom GraphicsLayer.
      * ```