@itwin/core-bentley 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/esm/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/esm/ObservableSet.js

@@ -1,48 +1,48 @@
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-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 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();
-        /** Emitted after `item` is deleted from this set. */
-        this.onDeleted = new BeEvent();
-        /** Emitted after this set's contents are cleared. */
-        this.onCleared = new 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();
-        }
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+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 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();
+        /** Emitted after `item` is deleted from this set. */
+        this.onDeleted = new BeEvent();
+        /** Emitted after this set's contents are cleared. */
+        this.onCleared = new 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();
+        }
+    }
+}
 //# sourceMappingURL=ObservableSet.js.map

package/lib/esm/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/esm/OneAtATimeAction.js

@@ -1,90 +1,90 @@
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-import { BentleyError } from "./BentleyError";
-/** @beta */
-export class AbandonedError extends Error {
-}
-/**
- * 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 ?? 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.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
- */
-export 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
-        }
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+import { BentleyError } from "./BentleyError";
+/** @beta */
+export class AbandonedError extends Error {
+}
+/**
+ * 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 ?? 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.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
+ */
+export 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
+        }
+    }
+}
 //# sourceMappingURL=OneAtATimeAction.js.map

package/lib/esm/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 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

package/lib/esm/OrderedId64Iterable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrderedId64Iterable.d.ts","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAE7C,cAAc;AACd,oBAAY,mBAAmB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AAEvD;;;;;;;GAOG;AACH,yBAAiB,mBAAmB,CAAC;IACnC;;;;;;OAMG;IACH,SAAgB,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAUhE;IAED;;;;;;OAMG;IACH,SAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAGnD;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAoB1F;IAED;;;OAGG;IACH,SAAgB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,OAAO,CAKhF;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,GAAG,EAAE,mBAAmB,GAAG,mBAAmB,CAEpE;IAED;;OAEG;IACH,SAAiB,cAAc,CAAC,GAAG,EAAE,mBAAmB,oCAavD;IAED;;OAEG;IACH,SAAgB,KAAK,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAE/F;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEtG;IAED;;OAEG;IACH,SAAgB,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEpG;IAED;;OAEG;IACH,SAAiB,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA0ClF;IAED;;OAEG;IACH,SAAiB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA6BzF;IAED;;OAEG;IACH,SAAiB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCAiCvF;CACF"}
+{"version":3,"file":"OrderedId64Iterable.d.ts","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAE7C,cAAc;AACd,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AAEvD;;;;;;;GAOG;AACH,yBAAiB,mBAAmB,CAAC;IACnC;;;;;;OAMG;IACH,SAAgB,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAUhE;IAED;;;;;;OAMG;IACH,SAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAGnD;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAoB1F;IAED;;;OAGG;IACH,SAAgB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,OAAO,CAKhF;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,GAAG,EAAE,mBAAmB,GAAG,mBAAmB,CAEpE;IAED;;OAEG;IACH,SAAiB,cAAc,CAAC,GAAG,EAAE,mBAAmB,oCAavD;IAED;;OAEG;IACH,SAAgB,KAAK,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAE/F;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEtG;IAED;;OAEG;IACH,SAAgB,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEpG;IAED;;OAEG;IACH,SAAiB,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA0ClF;IAED;;OAEG;IACH,SAAiB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA6BzF;IAED;;OAEG;IACH,SAAiB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCAiCvF;CACF"}