@itwin/core-bentley 3.6.0-dev.11 → 3.6.0-dev.21

package/lib/cjs/ObservableSet.d.ts

@@ -1,24 +1,24 @@
-/** @packageDocumentation
- * @module Collections
- */
-import { BeEvent } from "./BeEvent";
-/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.
- * @public
- */
-export declare class ObservableSet<T> extends Set<T> {
-    /** Emitted after `item` is added to this set. */
-    readonly onAdded: BeEvent<(item: T) => void>;
-    /** Emitted after `item` is deleted from this set. */
-    readonly onDeleted: BeEvent<(item: T) => void>;
-    /** Emitted after this set's contents are cleared. */
-    readonly onCleared: BeEvent<() => void>;
-    /** Construct a new ObservableSet.
-     * @param elements Optional elements with which to populate the new set.
-     */
-    constructor(elements?: Iterable<T> | undefined);
-    /** @internal */
-    delete(item: T): boolean;
-    /** @internal */
-    clear(): void;
-}
+/** @packageDocumentation
+ * @module Collections
+ */
+import { BeEvent } from "./BeEvent";
+/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.
+ * @public
+ */
+export declare class ObservableSet<T> extends Set<T> {
+    /** Emitted after `item` is added to this set. */
+    readonly onAdded: BeEvent<(item: T) => void>;
+    /** Emitted after `item` is deleted from this set. */
+    readonly onDeleted: BeEvent<(item: T) => void>;
+    /** Emitted after this set's contents are cleared. */
+    readonly onCleared: BeEvent<() => void>;
+    /** Construct a new ObservableSet.
+     * @param elements Optional elements with which to populate the new set.
+     */
+    constructor(elements?: Iterable<T> | undefined);
+    /** @internal */
+    delete(item: T): boolean;
+    /** @internal */
+    clear(): void;
+}
 //# sourceMappingURL=ObservableSet.d.ts.map

package/lib/cjs/ObservableSet.js

@@ -1,52 +1,52 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableSet = void 0;
-const BeEvent_1 = require("./BeEvent");
-/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.
- * @public
- */
-class ObservableSet extends Set {
-    /** Construct a new ObservableSet.
-     * @param elements Optional elements with which to populate the new set.
-     */
-    constructor(elements) {
-        // NB: Set constructor will invoke add(). Do not override until initialized.
-        super(elements);
-        /** Emitted after `item` is added to this set. */
-        this.onAdded = new BeEvent_1.BeEvent();
-        /** Emitted after `item` is deleted from this set. */
-        this.onDeleted = new BeEvent_1.BeEvent();
-        /** Emitted after this set's contents are cleared. */
-        this.onCleared = new BeEvent_1.BeEvent();
-        this.add = (item) => {
-            const prevSize = this.size;
-            const ret = super.add(item);
-            if (this.size !== prevSize)
-                this.onAdded.raiseEvent(item);
-            return ret;
-        };
-    }
-    /** @internal */
-    delete(item) {
-        const ret = super.delete(item);
-        if (ret)
-            this.onDeleted.raiseEvent(item);
-        return ret;
-    }
-    /** @internal */
-    clear() {
-        if (0 !== this.size) {
-            super.clear();
-            this.onCleared.raiseEvent();
-        }
-    }
-}
-exports.ObservableSet = ObservableSet;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableSet = void 0;
+const BeEvent_1 = require("./BeEvent");
+/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.
+ * @public
+ */
+class ObservableSet extends Set {
+    /** Construct a new ObservableSet.
+     * @param elements Optional elements with which to populate the new set.
+     */
+    constructor(elements) {
+        // NB: Set constructor will invoke add(). Do not override until initialized.
+        super(elements);
+        /** Emitted after `item` is added to this set. */
+        this.onAdded = new BeEvent_1.BeEvent();
+        /** Emitted after `item` is deleted from this set. */
+        this.onDeleted = new BeEvent_1.BeEvent();
+        /** Emitted after this set's contents are cleared. */
+        this.onCleared = new BeEvent_1.BeEvent();
+        this.add = (item) => {
+            const prevSize = this.size;
+            const ret = super.add(item);
+            if (this.size !== prevSize)
+                this.onAdded.raiseEvent(item);
+            return ret;
+        };
+    }
+    /** @internal */
+    delete(item) {
+        const ret = super.delete(item);
+        if (ret)
+            this.onDeleted.raiseEvent(item);
+        return ret;
+    }
+    /** @internal */
+    clear() {
+        if (0 !== this.size) {
+            super.clear();
+            this.onCleared.raiseEvent();
+        }
+    }
+}
+exports.ObservableSet = ObservableSet;
 //# sourceMappingURL=ObservableSet.js.map

package/lib/cjs/ObservableSet.js.map

@@ -1 +1 @@
-{"version":3,"file":"ObservableSet.js","sourceRoot":"","sources":["../../src/ObservableSet.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,uCAAoC;AAEpC;;GAEG;AACH,MAAa,aAAiB,SAAQ,GAAM;IAQ1C;;OAEG;IACH,YAAmB,QAAkC;QACnD,4EAA4E;QAC5E,KAAK,CAAC,QAAQ,CAAC,CAAC;QAZlB,iDAAiD;QACjC,YAAO,GAAG,IAAI,iBAAO,EAAqB,CAAC;QAC3D,qDAAqD;QACrC,cAAS,GAAG,IAAI,iBAAO,EAAqB,CAAC;QAC7D,qDAAqD;QACrC,cAAS,GAAG,IAAI,iBAAO,EAAc,CAAC;QASpD,IAAI,CAAC,GAAG,GAAG,CAAC,IAAO,EAAE,EAAE;YACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC;YAC3B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;gBACxB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAEhC,OAAO,GAAG,CAAC;QACb,CAAC,CAAC;IACJ,CAAC;IAED,gBAAgB;IACA,MAAM,CAAC,IAAO;QAC5B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,GAAG;YACL,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAElC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,gBAAgB;IACA,KAAK;QACnB,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE;YACnB,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;SAC7B;IACH,CAAC;CACF;AAzCD,sCAyCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Collections\r\n */\r\n\r\nimport { BeEvent } from \"./BeEvent\";\r\n\r\n/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.\r\n * @public\r\n */\r\nexport class ObservableSet<T> extends Set<T> {\r\n  /** Emitted after `item` is added to this set. */\r\n  public readonly onAdded = new BeEvent<(item: T) => void>();\r\n  /** Emitted after `item` is deleted from this set. */\r\n  public readonly onDeleted = new BeEvent<(item: T) => void>();\r\n  /** Emitted after this set's contents are cleared. */\r\n  public readonly onCleared = new BeEvent<() => void>();\r\n\r\n  /** Construct a new ObservableSet.\r\n   * @param elements Optional elements with which to populate the new set.\r\n   */\r\n  public constructor(elements?: Iterable<T> | undefined) {\r\n    // NB: Set constructor will invoke add(). Do not override until initialized.\r\n    super(elements);\r\n\r\n    this.add = (item: T) => { // eslint-disable-line @typescript-eslint/unbound-method\r\n      const prevSize = this.size;\r\n      const ret = super.add(item);\r\n      if (this.size !== prevSize)\r\n        this.onAdded.raiseEvent(item);\r\n\r\n      return ret;\r\n    };\r\n  }\r\n\r\n  /** @internal */\r\n  public override delete(item: T): boolean {\r\n    const ret = super.delete(item);\r\n    if (ret)\r\n      this.onDeleted.raiseEvent(item);\r\n\r\n    return ret;\r\n  }\r\n\r\n  /** @internal */\r\n  public override clear(): void {\r\n    if (0 !== this.size) {\r\n      super.clear();\r\n      this.onCleared.raiseEvent();\r\n    }\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"ObservableSet.js","sourceRoot":"","sources":["../../src/ObservableSet.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,uCAAoC;AAEpC;;GAEG;AACH,MAAa,aAAiB,SAAQ,GAAM;IAQ1C;;OAEG;IACH,YAAmB,QAAkC;QACnD,4EAA4E;QAC5E,KAAK,CAAC,QAAQ,CAAC,CAAC;QAZlB,iDAAiD;QACjC,YAAO,GAAG,IAAI,iBAAO,EAAqB,CAAC;QAC3D,qDAAqD;QACrC,cAAS,GAAG,IAAI,iBAAO,EAAqB,CAAC;QAC7D,qDAAqD;QACrC,cAAS,GAAG,IAAI,iBAAO,EAAc,CAAC;QASpD,IAAI,CAAC,GAAG,GAAG,CAAC,IAAO,EAAE,EAAE;YACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC;YAC3B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;gBACxB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAEhC,OAAO,GAAG,CAAC;QACb,CAAC,CAAC;IACJ,CAAC;IAED,gBAAgB;IACA,MAAM,CAAC,IAAO;QAC5B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,GAAG;YACL,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAElC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,gBAAgB;IACA,KAAK;QACnB,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE;YACnB,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;SAC7B;IACH,CAAC;CACF;AAzCD,sCAyCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Collections\n */\n\nimport { BeEvent } from \"./BeEvent\";\n\n/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.\n * @public\n */\nexport class ObservableSet<T> extends Set<T> {\n  /** Emitted after `item` is added to this set. */\n  public readonly onAdded = new BeEvent<(item: T) => void>();\n  /** Emitted after `item` is deleted from this set. */\n  public readonly onDeleted = new BeEvent<(item: T) => void>();\n  /** Emitted after this set's contents are cleared. */\n  public readonly onCleared = new BeEvent<() => void>();\n\n  /** Construct a new ObservableSet.\n   * @param elements Optional elements with which to populate the new set.\n   */\n  public constructor(elements?: Iterable<T> | undefined) {\n    // NB: Set constructor will invoke add(). Do not override until initialized.\n    super(elements);\n\n    this.add = (item: T) => { // eslint-disable-line @typescript-eslint/unbound-method\n      const prevSize = this.size;\n      const ret = super.add(item);\n      if (this.size !== prevSize)\n        this.onAdded.raiseEvent(item);\n\n      return ret;\n    };\n  }\n\n  /** @internal */\n  public override delete(item: T): boolean {\n    const ret = super.delete(item);\n    if (ret)\n      this.onDeleted.raiseEvent(item);\n\n    return ret;\n  }\n\n  /** @internal */\n  public override clear(): void {\n    if (0 !== this.size) {\n      super.clear();\n      this.onCleared.raiseEvent();\n    }\n  }\n}\n"]}

package/lib/cjs/OneAtATimeAction.d.ts

@@ -1,32 +1,32 @@
-/** @packageDocumentation
- * @module Utils
- */
-/** @beta */
-export declare class AbandonedError extends Error {
-}
-/**
- * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate
- * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP
- * request queue to grow such that the delay to service new requests is unbounded.
- *
- * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent
- * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.
- * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type
- * of operation, but the first and last request will always eventually complete.
- * @beta
- */
-export declare class OneAtATimeAction<T> {
-    private _active?;
-    private _pending?;
-    private _run;
-    msg: string;
-    /** Ctor for OneAtATimePromise.
-     * @param run The method that performs an action that creates the Promise.
-     */
-    constructor(run: (...args: any[]) => Promise<T>, msg?: string);
-    /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.
-     * @note Callers of this method *must* handle AbandonedError rejections.
-     */
-    request(...args: any[]): Promise<T>;
-}
+/** @packageDocumentation
+ * @module Utils
+ */
+/** @beta */
+export declare class AbandonedError extends Error {
+}
+/**
+ * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate
+ * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP
+ * request queue to grow such that the delay to service new requests is unbounded.
+ *
+ * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent
+ * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.
+ * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type
+ * of operation, but the first and last request will always eventually complete.
+ * @beta
+ */
+export declare class OneAtATimeAction<T> {
+    private _active?;
+    private _pending?;
+    private _run;
+    msg: string;
+    /** Ctor for OneAtATimePromise.
+     * @param run The method that performs an action that creates the Promise.
+     */
+    constructor(run: (...args: any[]) => Promise<T>, msg?: string);
+    /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.
+     * @note Callers of this method *must* handle AbandonedError rejections.
+     */
+    request(...args: any[]): Promise<T>;
+}
 //# sourceMappingURL=OneAtATimeAction.d.ts.map

package/lib/cjs/OneAtATimeAction.js

@@ -1,95 +1,95 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneAtATimeAction = exports.AbandonedError = void 0;
-const BentleyError_1 = require("./BentleyError");
-/** @beta */
-class AbandonedError extends Error {
-}
-exports.AbandonedError = AbandonedError;
-/**
- * An object that returns a Promise when you call [[init]], but supplies a way to abandon the promise if it is no longer relevant.
- * When you call abandon, the promise will be rejected. You must supply a [[run]] method to the constructor that
- * creates the real Promise for the underlying action. Notice that to use this class there are really two
- * Promises involved that are chained together. That makes this class less efficient than just using a Promise directly.
- */
-class PromiseWithAbandon {
-    /** Create a PromiseWithAbandon. After this call you must call [[init]] to create the underlying Promise.
-     * @param _run The method that creates the underlying Promise.
-     * @param _args An array of args to be passed to run when [[start]] is called.
-     */
-    constructor(_run, _args) {
-        this._run = _run;
-        this._args = _args;
-    }
-    /** Create a Promise that is chained to the underlying Promise, but is connected to the abandon method. */
-    async init(msg) {
-        return new Promise((resolve, reject) => {
-            this.abandon = (message) => reject(new AbandonedError(message !== null && message !== void 0 ? message : msg));
-            this._resolve = resolve;
-        });
-    }
-    /** Call the [[run]] method supplied to the ctor to start the underlying Promise. */
-    async start() {
-        try {
-            this._resolve(await this._run(...this._args));
-        }
-        catch (err) {
-            this.abandon(BentleyError_1.BentleyError.getErrorMessage(err)); // turn all errors from execution into abandoned errors, but keep the message
-        }
-    }
-}
-/**
- * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate
- * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP
- * request queue to grow such that the delay to service new requests is unbounded.
- *
- * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent
- * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.
- * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type
- * of operation, but the first and last request will always eventually complete.
- * @beta
- */
-class OneAtATimeAction {
-    /** Ctor for OneAtATimePromise.
-     * @param run The method that performs an action that creates the Promise.
-     */
-    constructor(run, msg = "abandoned") {
-        this._run = run;
-        this.msg = msg;
-    }
-    /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.
-     * @note Callers of this method *must* handle AbandonedError rejections.
-     */
-    async request(...args) {
-        const entry = new PromiseWithAbandon(this._run, args); // create an "abandon-able promise" object
-        const promise = entry.init(this.msg); // create the Promise from PromiseWithAbandon. Note: this must be called before we call start.
-        if (this._active !== undefined) { // is there an active request?
-            if (this._pending) // yes. If there is also a pending request, this one replaces it and previous one is abandoned
-                this._pending.abandon(); // rejects previous call to this method, throwing AbandonedError.
-            this._pending = entry;
-        }
-        else {
-            this._active = entry; // this is the first request, start it.
-            entry.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        }
-        try {
-            return await promise;
-        }
-        finally {
-            // do all of this whether promise was fulfilled or rejected
-            this._active = this._pending; // see if there's a pending request waiting
-            this._pending = undefined; // clear pending
-            if (this._active)
-                this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        }
-    }
-}
-exports.OneAtATimeAction = OneAtATimeAction;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneAtATimeAction = exports.AbandonedError = void 0;
+const BentleyError_1 = require("./BentleyError");
+/** @beta */
+class AbandonedError extends Error {
+}
+exports.AbandonedError = AbandonedError;
+/**
+ * An object that returns a Promise when you call [[init]], but supplies a way to abandon the promise if it is no longer relevant.
+ * When you call abandon, the promise will be rejected. You must supply a [[run]] method to the constructor that
+ * creates the real Promise for the underlying action. Notice that to use this class there are really two
+ * Promises involved that are chained together. That makes this class less efficient than just using a Promise directly.
+ */
+class PromiseWithAbandon {
+    /** Create a PromiseWithAbandon. After this call you must call [[init]] to create the underlying Promise.
+     * @param _run The method that creates the underlying Promise.
+     * @param _args An array of args to be passed to run when [[start]] is called.
+     */
+    constructor(_run, _args) {
+        this._run = _run;
+        this._args = _args;
+    }
+    /** Create a Promise that is chained to the underlying Promise, but is connected to the abandon method. */
+    async init(msg) {
+        return new Promise((resolve, reject) => {
+            this.abandon = (message) => reject(new AbandonedError(message !== null && message !== void 0 ? message : msg));
+            this._resolve = resolve;
+        });
+    }
+    /** Call the [[run]] method supplied to the ctor to start the underlying Promise. */
+    async start() {
+        try {
+            this._resolve(await this._run(...this._args));
+        }
+        catch (err) {
+            this.abandon(BentleyError_1.BentleyError.getErrorMessage(err)); // turn all errors from execution into abandoned errors, but keep the message
+        }
+    }
+}
+/**
+ * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate
+ * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP
+ * request queue to grow such that the delay to service new requests is unbounded.
+ *
+ * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent
+ * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.
+ * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type
+ * of operation, but the first and last request will always eventually complete.
+ * @beta
+ */
+class OneAtATimeAction {
+    /** Ctor for OneAtATimePromise.
+     * @param run The method that performs an action that creates the Promise.
+     */
+    constructor(run, msg = "abandoned") {
+        this._run = run;
+        this.msg = msg;
+    }
+    /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.
+     * @note Callers of this method *must* handle AbandonedError rejections.
+     */
+    async request(...args) {
+        const entry = new PromiseWithAbandon(this._run, args); // create an "abandon-able promise" object
+        const promise = entry.init(this.msg); // create the Promise from PromiseWithAbandon. Note: this must be called before we call start.
+        if (this._active !== undefined) { // is there an active request?
+            if (this._pending) // yes. If there is also a pending request, this one replaces it and previous one is abandoned
+                this._pending.abandon(); // rejects previous call to this method, throwing AbandonedError.
+            this._pending = entry;
+        }
+        else {
+            this._active = entry; // this is the first request, start it.
+            entry.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
+        }
+        try {
+            return await promise;
+        }
+        finally {
+            // do all of this whether promise was fulfilled or rejected
+            this._active = this._pending; // see if there's a pending request waiting
+            this._pending = undefined; // clear pending
+            if (this._active)
+                this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises
+        }
+    }
+}
+exports.OneAtATimeAction = OneAtATimeAction;
 //# sourceMappingURL=OneAtATimeAction.js.map

package/lib/cjs/OneAtATimeAction.js.map

@@ -1 +1 @@
-{"version":3,"file":"OneAtATimeAction.js","sourceRoot":"","sources":["../../src/OneAtATimeAction.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,iDAA8C;AAE9C,YAAY;AACZ,MAAa,cAAe,SAAQ,KAAK;CAAI;AAA7C,wCAA6C;AAE7C;;;;;GAKG;AACH,MAAM,kBAAkB;IAKtB;;;OAGG;IACH,YAAoB,IAAoC,EAAU,KAAY;QAA1D,SAAI,GAAJ,IAAI,CAAgC;QAAU,UAAK,GAAL,KAAK,CAAO;IAAI,CAAC;IAEnF,0GAA0G;IACnG,KAAK,CAAC,IAAI,CAAC,GAAW;QAC3B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,IAAI,CAAC,OAAO,GAAG,CAAC,OAAgB,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,cAAc,CAAC,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,GAAG,CAAC,CAAC,CAAC;YAChF,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,oFAAoF;IAC7E,KAAK,CAAC,KAAK;QAChB,IAAI;YACF,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAC/C;QAAC,OAAO,GAAG,EAAE;YACZ,IAAI,CAAC,OAAO,CAAC,2BAAY,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,6EAA6E;SAC/H;IACH,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAa,gBAAgB;IAM3B;;OAEG;IACH,YAAY,GAAmC,EAAE,GAAG,GAAG,WAAW;QAChE,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,GAAG,IAAW;QACjC,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAAI,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,0CAA0C;QACpG,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,8FAA8F;QAEpI,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,EAAE,8BAA8B;YAC9D,IAAI,IAAI,CAAC,QAAQ,EAAE,8FAA8F;gBAC/G,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,iEAAiE;YAC5F,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;SACvB;aAAM;YACL,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC,uCAAuC;YAC7D,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,8DAA8D;SAC9E;QAED,IAAI;YACF,OAAO,MAAM,OAAO,CAAC;SACtB;gBAAS;YACR,2DAA2D;YAC3D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,2CAA2C;YACzE,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,gBAAgB;YAC3C,IAAI,IAAI,CAAC,OAAO;gBACd,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,8DAA8D;SACvF;IACH,CAAC;CACF;AAxCD,4CAwCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\nimport { BentleyError } from \"./BentleyError\";\r\n\r\n/** @beta */\r\nexport class AbandonedError extends Error { }\r\n\r\n/**\r\n * An object that returns a Promise when you call [[init]], but supplies a way to abandon the promise if it is no longer relevant.\r\n * When you call abandon, the promise will be rejected. You must supply a [[run]] method to the constructor that\r\n * creates the real Promise for the underlying action. Notice that to use this class there are really two\r\n * Promises involved that are chained together. That makes this class less efficient than just using a Promise directly.\r\n */\r\nclass PromiseWithAbandon<T> {\r\n  /** Method to abandon the Promise created by [[init]] while it is outstanding. The promise will be rejected. */\r\n  public abandon!: (msg?: string) => void;\r\n  private _resolve!: (val: any) => void;\r\n\r\n  /** Create a PromiseWithAbandon. After this call you must call [[init]] to create the underlying Promise.\r\n   * @param _run The method that creates the underlying Promise.\r\n   * @param _args An array of args to be passed to run when [[start]] is called.\r\n   */\r\n  constructor(private _run: (...args: any[]) => Promise<T>, private _args: any[]) { }\r\n\r\n  /** Create a Promise that is chained to the underlying Promise, but is connected to the abandon method. */\r\n  public async init(msg: string): Promise<T> {\r\n    return new Promise<T>((resolve, reject) => {\r\n      this.abandon = (message?: string) => reject(new AbandonedError(message ?? msg));\r\n      this._resolve = resolve;\r\n    });\r\n  }\r\n\r\n  /** Call the [[run]] method supplied to the ctor to start the underlying Promise. */\r\n  public async start() {\r\n    try {\r\n      this._resolve(await this._run(...this._args));\r\n    } catch (err) {\r\n      this.abandon(BentleyError.getErrorMessage(err)); // turn all errors from execution into abandoned errors, but keep the message\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate\r\n * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP\r\n * request queue to grow such that the delay to service new requests is unbounded.\r\n *\r\n * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent\r\n * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.\r\n * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type\r\n * of operation, but the first and last request will always eventually complete.\r\n * @beta\r\n */\r\nexport class OneAtATimeAction<T> {\r\n  private _active?: PromiseWithAbandon<T>;\r\n  private _pending?: PromiseWithAbandon<T>;\r\n  private _run: (...args: any[]) => Promise<T>;\r\n  public msg: string;\r\n\r\n  /** Ctor for OneAtATimePromise.\r\n   * @param run The method that performs an action that creates the Promise.\r\n   */\r\n  constructor(run: (...args: any[]) => Promise<T>, msg = \"abandoned\") {\r\n    this._run = run;\r\n    this.msg = msg;\r\n  }\r\n\r\n  /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.\r\n   * @note Callers of this method *must* handle AbandonedError rejections.\r\n   */\r\n  public async request(...args: any[]): Promise<T> {\r\n    const entry = new PromiseWithAbandon<T>(this._run, args); // create an \"abandon-able promise\" object\r\n    const promise = entry.init(this.msg); // create the Promise from PromiseWithAbandon. Note: this must be called before we call start.\r\n\r\n    if (this._active !== undefined) { // is there an active request?\r\n      if (this._pending) // yes. If there is also a pending request, this one replaces it and previous one is abandoned\r\n        this._pending.abandon(); // rejects previous call to this method, throwing AbandonedError.\r\n      this._pending = entry;\r\n    } else {\r\n      this._active = entry; // this is the first request, start it.\r\n      entry.start(); // eslint-disable-line @typescript-eslint/no-floating-promises\r\n    }\r\n\r\n    try {\r\n      return await promise;\r\n    } finally {\r\n      // do all of this whether promise was fulfilled or rejected\r\n      this._active = this._pending; // see if there's a pending request waiting\r\n      this._pending = undefined; // clear pending\r\n      if (this._active)\r\n        this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises\r\n    }\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"OneAtATimeAction.js","sourceRoot":"","sources":["../../src/OneAtATimeAction.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,iDAA8C;AAE9C,YAAY;AACZ,MAAa,cAAe,SAAQ,KAAK;CAAI;AAA7C,wCAA6C;AAE7C;;;;;GAKG;AACH,MAAM,kBAAkB;IAKtB;;;OAGG;IACH,YAAoB,IAAoC,EAAU,KAAY;QAA1D,SAAI,GAAJ,IAAI,CAAgC;QAAU,UAAK,GAAL,KAAK,CAAO;IAAI,CAAC;IAEnF,0GAA0G;IACnG,KAAK,CAAC,IAAI,CAAC,GAAW;QAC3B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,IAAI,CAAC,OAAO,GAAG,CAAC,OAAgB,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,cAAc,CAAC,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,GAAG,CAAC,CAAC,CAAC;YAChF,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,oFAAoF;IAC7E,KAAK,CAAC,KAAK;QAChB,IAAI;YACF,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAC/C;QAAC,OAAO,GAAG,EAAE;YACZ,IAAI,CAAC,OAAO,CAAC,2BAAY,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,6EAA6E;SAC/H;IACH,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAa,gBAAgB;IAM3B;;OAEG;IACH,YAAY,GAAmC,EAAE,GAAG,GAAG,WAAW;QAChE,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,GAAG,IAAW;QACjC,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAAI,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,0CAA0C;QACpG,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,8FAA8F;QAEpI,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,EAAE,8BAA8B;YAC9D,IAAI,IAAI,CAAC,QAAQ,EAAE,8FAA8F;gBAC/G,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,iEAAiE;YAC5F,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;SACvB;aAAM;YACL,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC,uCAAuC;YAC7D,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,8DAA8D;SAC9E;QAED,IAAI;YACF,OAAO,MAAM,OAAO,CAAC;SACtB;gBAAS;YACR,2DAA2D;YAC3D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,2CAA2C;YACzE,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,gBAAgB;YAC3C,IAAI,IAAI,CAAC,OAAO;gBACd,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,8DAA8D;SACvF;IACH,CAAC;CACF;AAxCD,4CAwCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\nimport { BentleyError } from \"./BentleyError\";\n\n/** @beta */\nexport class AbandonedError extends Error { }\n\n/**\n * An object that returns a Promise when you call [[init]], but supplies a way to abandon the promise if it is no longer relevant.\n * When you call abandon, the promise will be rejected. You must supply a [[run]] method to the constructor that\n * creates the real Promise for the underlying action. Notice that to use this class there are really two\n * Promises involved that are chained together. That makes this class less efficient than just using a Promise directly.\n */\nclass PromiseWithAbandon<T> {\n  /** Method to abandon the Promise created by [[init]] while it is outstanding. The promise will be rejected. */\n  public abandon!: (msg?: string) => void;\n  private _resolve!: (val: any) => void;\n\n  /** Create a PromiseWithAbandon. After this call you must call [[init]] to create the underlying Promise.\n   * @param _run The method that creates the underlying Promise.\n   * @param _args An array of args to be passed to run when [[start]] is called.\n   */\n  constructor(private _run: (...args: any[]) => Promise<T>, private _args: any[]) { }\n\n  /** Create a Promise that is chained to the underlying Promise, but is connected to the abandon method. */\n  public async init(msg: string): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      this.abandon = (message?: string) => reject(new AbandonedError(message ?? msg));\n      this._resolve = resolve;\n    });\n  }\n\n  /** Call the [[run]] method supplied to the ctor to start the underlying Promise. */\n  public async start() {\n    try {\n      this._resolve(await this._run(...this._args));\n    } catch (err) {\n      this.abandon(BentleyError.getErrorMessage(err)); // turn all errors from execution into abandoned errors, but keep the message\n    }\n  }\n}\n\n/**\n * Orchestrator of a one-at-a-time activity. This concept is useful only for *replaceable* operations (that is, operations where subsequent requests replace and obviate\n * the need for previous requests. E.g. over slow HTTP connections, without this class, the stream of requests can overwhelm the connection, and cause the HTTP\n * request queue to grow such that the delay to service new requests is unbounded.\n *\n * With this class, we issue the initial request immediately. When the second request arrives before the first one completes, it becomes *pending*. If subsequent\n * requests arrive with a pending request, the current pending request is *abandoned* (its Promise is rejected) and the new request becomes pending.\n * When the active request completes, the pending request (if present) is started. In this manner there will only ever be one outstanding HTTP request for this type\n * of operation, but the first and last request will always eventually complete.\n * @beta\n */\nexport class OneAtATimeAction<T> {\n  private _active?: PromiseWithAbandon<T>;\n  private _pending?: PromiseWithAbandon<T>;\n  private _run: (...args: any[]) => Promise<T>;\n  public msg: string;\n\n  /** Ctor for OneAtATimePromise.\n   * @param run The method that performs an action that creates the Promise.\n   */\n  constructor(run: (...args: any[]) => Promise<T>, msg = \"abandoned\") {\n    this._run = run;\n    this.msg = msg;\n  }\n\n  /** Add a new request to this OneAtATimePromise. The request will only run when no other outstanding requests are active.\n   * @note Callers of this method *must* handle AbandonedError rejections.\n   */\n  public async request(...args: any[]): Promise<T> {\n    const entry = new PromiseWithAbandon<T>(this._run, args); // create an \"abandon-able promise\" object\n    const promise = entry.init(this.msg); // create the Promise from PromiseWithAbandon. Note: this must be called before we call start.\n\n    if (this._active !== undefined) { // is there an active request?\n      if (this._pending) // yes. If there is also a pending request, this one replaces it and previous one is abandoned\n        this._pending.abandon(); // rejects previous call to this method, throwing AbandonedError.\n      this._pending = entry;\n    } else {\n      this._active = entry; // this is the first request, start it.\n      entry.start(); // eslint-disable-line @typescript-eslint/no-floating-promises\n    }\n\n    try {\n      return await promise;\n    } finally {\n      // do all of this whether promise was fulfilled or rejected\n      this._active = this._pending; // see if there's a pending request waiting\n      this._pending = undefined; // clear pending\n      if (this._active)\n        this._active.start(); // eslint-disable-line @typescript-eslint/no-floating-promises\n    }\n  }\n}\n"]}

package/lib/cjs/OrderedId64Iterable.d.ts

@@ -1,75 +1,75 @@
-/** @packageDocumentation
- * @module Ids
- */
-import { CompressedId64Set } from "./CompressedId64Set";
-import { Id64Array, Id64String } from "./Id";
-/** @public */
-export declare type OrderedId64Iterable = Iterable<Id64String>;
-/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
- * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
- * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
- * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
- * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
- * @see [[OrderedId64Array]] for a mutable implementation.
- * @public
- */
-export declare namespace OrderedId64Iterable {
-    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
-     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
-     * a positive number if lhs > rhs, or zero if lhs == rhs.
-     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
-     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
-     */
-    function compare(lhs: Id64String, rhs: Id64String): number;
-    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
-     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
-     * @returns the input array.
-     * @note This function returns its input for consistency with Javascript's
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
-     * It **does not** create a **new** array.
-     */
-    function sortArray(ids: Id64Array): Id64Array;
-    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean;
-    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
-     * @param ids A well-formed, ordered collection of zero or more valid Ids.
-     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
-     */
-    function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function unique(ids: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function uniqueIterator(ids: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-}
+/** @packageDocumentation
+ * @module Ids
+ */
+import { CompressedId64Set } from "./CompressedId64Set";
+import { Id64Array, Id64String } from "./Id";
+/** @public */
+export declare type OrderedId64Iterable = Iterable<Id64String>;
+/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
+ * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
+ * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
+ * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
+ * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
+ * @see [[OrderedId64Array]] for a mutable implementation.
+ * @public
+ */
+export declare namespace OrderedId64Iterable {
+    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
+     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
+     * a positive number if lhs > rhs, or zero if lhs == rhs.
+     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
+     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
+     */
+    function compare(lhs: Id64String, rhs: Id64String): number;
+    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
+     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
+     * @returns the input array.
+     * @note This function returns its input for consistency with Javascript's
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
+     * It **does not** create a **new** array.
+     */
+    function sortArray(ids: Id64Array): Id64Array;
+    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean;
+    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
+     * @param ids A well-formed, ordered collection of zero or more valid Ids.
+     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
+     */
+    function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function unique(ids: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function uniqueIterator(ids: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+}
 //# sourceMappingURL=OrderedId64Iterable.d.ts.map