@rockrms/obsidian-framework 17.5.2 → 18.1.0

package/types/Utility/linq.d.ts

@@ -14,6 +14,7 @@ type PredicateFn<T> = (value: T, index: number) => boolean;
 type ValueComparer<T> = (a: T, b: T) => number;
 /**
  * Provides LINQ style access to an array of elements.
+ * @deprecated since version 18.0
  */
 export declare class List<T> {
     /** The elements being tracked by this list. */
@@ -216,83 +217,254 @@ export declare class Enumerable<T> {
      */
     [Symbol.iterator](): Iterator<T>;
     /**
-     * Filters the sequence to include only elements that satisfy the predicate.
-     * @param predicate - A function to test each element for a condition.
-     * @returns A new Enumerable containing the filtered elements.
+     * Aggregates the elements of the sequence using a specified accumulator function and seed value.
+     *
+     * This method realizes the enumerable and iterates through each element immediately.
+     *
+     * Use `scan()` for a lazy version of this method.
+     *
+     * @param accumulator - A function that accumulates each element.
+     * @param seed - The initial value for the accumulation.
+     * @returns The aggregated value.
      */
-    where(predicate: (item: T) => boolean): Enumerable<T>;
+    aggregate<U>(accumulator: (acc: U, item: T, index: number) => U, seed: U): U;
     /**
-     * Projects each element of the sequence into a new form.
-     * @param selector - A function to project each element into a new form.
-     * @returns A new Enumerable with the projected elements.
+     * Determines whether all elements in the sequence satisfy a condition or if the sequence contains any elements.
+     * @param predicate - An optional function to test each element for a condition.
+     * @returns `true` if all elements satisfy the condition or if the collection is empty; otherwise, `false`.
      */
-    select<U>(selector: (item: T) => U): Enumerable<U>;
+    all(predicate: (item: T) => boolean): boolean;
     /**
-     * Returns a new Enumerable that skips the first `count` elements of the sequence.
-     * @param count - The number of elements to skip.
-     * @returns A new Enumerable that skips the specified number of elements.
+     * Determines whether any elements in the sequence satisfy a condition or if the sequence contains any elements.
+     * @param predicate - An optional function to test each element for a condition.
+     * @returns `true` if any elements satisfy the condition; otherwise, `false`.
      */
-    skip(count: number): Enumerable<T>;
+    any(predicate?: (item: T) => boolean): boolean;
     /**
-     * Returns a new Enumerable that contains the first `count` elements of the sequence.
-     * @param count - The number of elements to take.
-     * @returns A new Enumerable containing the taken elements.
+     * Computes the average of the projected numeric values in the sequence.
+     * @param selector - A function that selects the number from each element.
+     * @returns The average of the numbers.
+     * @throws Error if no valid numeric elements are found.
      */
-    take(count: number): Enumerable<T>;
+    average(selector: (item: T) => number): number;
+    /**
+     * Casts the elements of the sequence to the specified type.
+     * Performs a runtime type check for each element and throws an
+     * error if any element cannot be cast to the target type.
+     *
+     * @template U The target type to cast the elements to (must extend `T`).
+     * @param typeCheck A runtime type check function that verifies if the element is of type `U`.
+     * @returns A new Enumerable containing the elements cast to type `U`.
+     * @throws Error if any element cannot be cast to the specified type.
+     *
+     * @example
+     * const numbers = Enumerable.from([1, 2, 3])
+     *     // .select(...) //some projection that results in unknown type
+     *     .cast<number>(x => typeof x === "number"); // cast back to number.
+     * console.log(numbers.toArray()); // [1, 2, 3]
+     *
+     * @example
+     * const badCast = Enumerable.from([1, "hello"])
+     *     .cast<number>((x): x is number => typeof x === "number");
+     * // Throws: Invalid cast: Value 'hello' cannot be cast to the specified type.
+     */
+    cast<U extends T>(typeCheck: (item: T) => item is U): Enumerable<U>;
+    /**
+     * Concatenates the current sequence with another sequence.
+     * @param second - The second sequence to concatenate.
+     * @returns A new Enumerable containing the concatenated elements.
+     */
+    concat(second: Iterable<T>): this;
+    /**
+     * Returns the number of elements in the sequence.
+     * @returns The total number of elements.
+     */
+    count(): number;
+    /**
+     * Returns the number of elements in the sequence that satisfy the specified predicate.
+     * @param predicate A function to test each element.
+     * @returns The number of matching elements.
+     */
+    count(predicate: (item: T) => boolean): number;
+    /**
+     * Returns distinct elements from the sequence, using strict equality.
+     *
+     * Works well for primitives (numbers, strings, booleans, symbols)
+     *
+     * @returns A new Enumerable with unique elements.
+     */
+    distinct(): this;
+    /**
+     * Returns distinct elements from the sequence based on a key selector.
+     * @param keySelector A function to extract the key for comparison.
+     * @returns A new Enumerable with unique elements by key.
+     */
+    distinctBy<TKey>(keySelector: (item: T) => TKey): this;
+    /**
+     * Returns the first element from the collection if there are any elements.
+     * Otherwise will throw an exception.
+     *
+     * @returns The first element in the collection.
+     */
+    first(): T;
+    /**
+     * Filters the list by the predicate and then returns the first element
+     * in the collection if any remain. Otherwise throws an exception.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The first element in the collection.
+     */
+    first(predicate: PredicateFn<T>): T;
+    /**
+     * Returns the first element of the sequence or `undefined` if the sequence is empty.
+     * @returns The first element of the sequence or `undefined`.
+     */
+    firstOrDefault(): T | undefined;
     /**
      * Returns the first element of the sequence or a default value if the sequence is empty.
      * @param defaultValue - The default value to return if the sequence is empty.
      * @returns The first element of the sequence or the default value.
      */
-    firstOrDefault(defaultValue?: T): T | undefined;
+    firstOrDefault(defaultValue: T): T;
     /**
-     * Returns the last element of the sequence, or a default value if the sequence is empty.
-     * @param defaultValue - The default value to return if the sequence is empty.
-     * @returns The last element of the sequence, or the provided default value.
+     * Returns the first element of the sequence that satisfies the specified predicate,
+     * or `undefined` if no such element is found.
+     *
+     * @param predicate A function to test each element for a condition.
+     * @returns The first element that matches the predicate, or `undefined` if none match.
      *
      * @example
-     * const numbers = Enumerable.from([1, 2, 3]);
-     * console.log(numbers.lastOrDefault()); // Outputs: 3
+     * const numbers = Enumerable.from([1, 2, 3, 4]);
+     * const firstEven = numbers.firstOrDefault(n => n % 2 === 0);
+     * console.log(firstEven); // Outputs: 2
      *
      * @example
      * const empty = Enumerable.from<number>([]);
-     * console.log(empty.lastOrDefault(0)); // Outputs: 0
+     * const result = empty.firstOrDefault(n => n > 0);
+     * console.log(result); // Outputs: undefined
      */
-    lastOrDefault(defaultValue?: T): T | undefined;
+    firstOrDefault(predicate: (item: T) => boolean): T | undefined;
     /**
-     * Aggregates the elements of the sequence using a specified accumulator function and seed value.
-     * @param accumulator - A function that accumulates each element.
-     * @param seed - The initial value for the accumulation.
-     * @returns The aggregated value.
+     * Executes a specified action for each element in the sequence.
+     * @param action - A function to execute for each element.
      */
-    aggregate<U>(accumulator: (acc: U, item: T, index: number) => U, seed: U): U;
+    forEach(action: (item: T) => void): void;
     /**
-     * Determines whether any elements in the sequence satisfy a condition or if the sequence contains any elements.
-     * @param predicate - An optional function to test each element for a condition.
-     * @returns `true` if any elements satisfy the condition; otherwise, `false`.
+     * Groups the elements of a sequence according to a specified key selector function.
+     * Each grouping is an Enumerable with a `.key` property.
+     *
+     * @param keySelector A function to extract the key for each element.
+     * @returns A new Enumerable of groupings.
      */
-    any(predicate?: (item: T) => boolean): boolean;
+    groupBy<TKey>(keySelector: (item: T) => TKey): Enumerable<GroupedEnumerable<TKey, T>>;
     /**
-     * Determines whether all elements in the sequence satisfy a condition or if the sequence contains any elements.
-     * @param predicate - An optional function to test each element for a condition.
-     * @returns `true` if all elements satisfy the condition; otherwise, `false`.
+     * Returns the last element of the sequence.
+     * @returns The last element.
+     * @throws If the sequence is empty.
      */
-    all(predicate: (item: T) => boolean): boolean;
+    last(): T;
     /**
-     * Executes a specified action for each element in the sequence.
-     * @param action - A function to execute for each element.
+     * Returns the last element of the sequence that satisfies the predicate.
+     * @param predicate A function to test each element.
+     * @returns The last matching element.
+     * @throws If no matching element is found.
      */
-    forEach(action: (item: T) => void): void;
+    last(predicate: (item: T) => boolean): T;
     /**
-     * Converts the sequence into an array.
-     * @returns An array containing all elements in the sequence.
+     * Returns the last element of the sequence, or `undefined` if the sequence is empty.
+     * @returns The last element of the sequence, or `undefined`.
+     *
+     * @example
+     * const numbers = Enumerable.from([1, 2, 3]);
+     * console.log(numbers.lastOrDefault()); // Outputs: 3
+     *
+     * @example
+     * const empty = Enumerable.from<number>([]);
+     * console.log(empty.lastOrDefault()); // Outputs: undefined
      */
-    toArray(): T[];
+    lastOrDefault(): T | undefined;
     /**
-     * Converts the sequence into a List.
-     * @returns An List containing all elements in the sequence.
+     * Returns the last element of the sequence, or a default value if the sequence is empty.
+     * @param defaultValue - The default value to return if the sequence is empty.
+     * @returns The last element of the sequence, or the provided default value.
+     *
+     * @example
+     * const numbers = Enumerable.from([1, 2, 3]);
+     * console.log(numbers.lastOrDefault()); // Outputs: 3
+     *
+     * @example
+     * const empty = Enumerable.from<number>([]);
+     * console.log(empty.lastOrDefault(0)); // Outputs: 0
+     */
+    lastOrDefault(defaultValue: T): T;
+    /**
+     * Returns the last element in the sequence that satisfies the given predicate,
+     * or `undefined` if no such element is found.
+     *
+     * @param predicate A function to test each element.
+     * @returns The last matching element, or `undefined`.
+     *
+     * @example
+     * const nums = Enumerable.from([1, 2, 3, 4]);
+     * console.log(nums.lastOrDefault(x => x % 2 === 0)); // 4
      */
-    toList(): List<T>;
+    lastOrDefault(predicate: (item: T) => boolean): T | undefined;
+    /**
+     * Returns the maximum element of the sequence.
+     *
+     * @template T The type of the elements in the sequence.
+     * @param selector A function to project each element to a numeric, comparable value.
+     * @returns The maximum element or `undefined` if the sequence is empty.
+     *
+     * @example
+     * Enumerable.from([3, 7, 2, 9]).max(); // 9
+     * Enumerable.from([{x: 1}, {x: 5}]).max(e => e.x); // 5
+     */
+    max(selector: (item: T) => number): number | undefined;
+    /**
+     * Returns the minimum element of the sequence.
+     *
+     * @template T The type of the elements in the sequence.
+     * @param selector A function to project each element to a numeric, comparable value.
+     * @returns The minimum element or `undefined` if the sequence is empty.
+     *
+     * @example
+     * Enumerable.from([{x: 1}, {x: 5}]).min(e => e.x); // 1
+     */
+    min(selector: (item: T) => number): number | undefined;
+    /**
+     * Returns the maximum element of the sequence.
+     *
+     * @template T The type of the elements in the sequence.
+     * @param selector A function to project each element to a numeric, comparable value.
+     * @returns The maximum element or `undefined` if the sequence is empty.
+     *
+
+        let maxItem = selector(first.value);
+
+        for (let next = self.next(); !next.done; next = self.next()) {
+            const value = selector(next.value);
+            if (value > maxItem) {
+                maxItem = value;
+            }
+        }
+
+        return maxItem;
+    }
+
+    /**
+     * Filters the sequence and returns only elements of the specified type.
+     * @template U The target type to filter by.
+     * @param typeCheck - A runtime check function to validate the type of each element.
+     * @returns A new Enumerable containing elements of type `U`.
+     *
+     * @example
+     * const mixed = Enumerable.from([1, "hello", true, 42]);
+     * const numbers = mixed.ofType<number>(item => typeof item === "number");
+     * console.log(numbers.toArray()); // Outputs: [1, 42]
+     */
+    ofType<U extends T>(typeCheck: (item: T) => item is U): Enumerable<U>;
     /**
      * Sorts the elements of the sequence in ascending order.
      * @param keySelector - Function to extract the key for comparison.
@@ -308,10 +480,124 @@ export declare class Enumerable<T> {
      */
     orderByDescending<U>(keySelector: (item: T) => U, comparer?: (a: U, b: U) => number): OrderedEnumerable<T>;
     /**
-     * Returns a generator that yields each element of the sequence paired with its index.
+     * Returns a new sequence with the specified element(s) prepended to the start.
+     *
+     * @template T The type of elements in the sequence.
+     * @param items One or more elements to prepend.
+     * @returns A new Enumerable with the items inserted before the existing sequence.
+     *
+     * @example
+     * const nums = Enumerable.from([2, 3]);
+     * const withOne = nums.prepend(1);
+     * console.log(withOne.toArray()); // [1, 2, 3]
+     *
+     * @example
+     * const moreNums = nums.prepend(-1, 0, 1);
+     * console.log(moreNums.toArray()); // [-1, 0, 1, 2, 3]
+     */
+    prepend(items: Iterable<T>): this;
+    /**
+     * Applies an accumulator function over the sequence, yielding each intermediate result.
+     * The first yielded value is based on the seed provided.
+     *
+     * This behaves like a "scan" or "running total" operation in functional programming.
+     * It is the lazy counterpart to `aggregate()` that preserves intermediate state at each step.
+     *
+     * @template U The type of the accumulated value.
+     * @param seed The initial accumulator value.
+     * @param accumulator A function that takes the accumulated value, the current element, and the index,
+     *                    and returns the new accumulated value.
+     * @returns An Enumerable of the intermediate accumulated values.
      *
-     * @generator
-     * @yields {[T, number]} A tuple containing the element and its zero-based index.
+     * @example
+     * const values = Enumerable.from([1, 2, 3, 4])
+     *     .scan(0, (acc, val) => acc + val)
+     *     .toArray();
+     * // Output: [1, 3, 6, 10]
+     *
+     * @example
+     * const withIndex = Enumerable.from(["a", "b", "c"])
+     *     .scan([], (acc, item, index) => [...acc, `${index}:${item}`])
+     *     .toArray();
+     * // Output: [["0:a"], ["0:a", "1:b"], ["0:a", "1:b", "2:c"]]
+     */
+    scan<U>(seed: U, accumulator: (acc: U, item: T, index: number) => U): Enumerable<U>;
+    /**
+     * Projects each element of the sequence into a new form.
+     * @param selector - A function to project each element into a new form.
+     * @returns A new Enumerable with the projected elements.
+     */
+    select<U>(selector: (item: T) => U): Enumerable<U>;
+    /**
+     * Projects each element of the sequence to an iterable and flattens the resulting sequences into one sequence.
+     * @param collectionSelector A transform function to apply to each element.
+     * @returns A new Enumerable containing the flattened results.
+     */
+    selectMany<U>(collectionSelector: (item: T) => Iterable<U>): Enumerable<U>;
+    /**
+     * Determines whether two sequences are equal by comparing their elements using
+     * strict equality (`===`) or an optional equality comparer.
+     *
+     * @param other The other sequence to compare to.
+     * @param comparer Optional equality comparer function. Defaults to strict equality.
+     * @returns `true` if both sequences have the same length and all elements are equal; otherwise, `false`.
+     *
+     * @example
+     * const seq1 = Enumerable.from([1, 2, 3]);
+     * const seq2 = Enumerable.from([1, 2, 3]);
+     * console.log(seq1.sequenceEqual(seq2)); // Outputs: true
+     *
+     * @example
+     * const seq3 = Enumerable.from(["a", "b", "c"]);
+     * const seq4 = Enumerable.from(["a", "B", "c"]);
+     * console.log(seq3.sequenceEqual(seq4, (a, b) => a.toLowerCase() === b.toLowerCase())); // Outputs: true
+     */
+    sequenceEqual(other: Iterable<T>, comparer?: (a: T, b: T) => boolean): boolean;
+    /**
+     * Returns a new Enumerable that skips the first `count` elements of the sequence.
+     * @param count - The number of elements to skip.
+     * @returns A new Enumerable that skips the specified number of elements.
+     */
+    skip(count: number): this;
+    /**
+     * Recreates an instance of the *same runtime class*.
+     * This allows subtype method chaining to return the subtype instead of Enumerable<T>.
+     */
+    protected spawn(factory: () => Iterable<T>): this;
+    /**
+     * Computes the sum of the projected numeric values in the list.
+     * @param selector - A function that selects the number from each element.
+     * @returns The sum of the numbers.
+     */
+    sum(selector: (item: T) => number): number;
+    /**
+     * Returns a new Enumerable that contains the first `count` elements of the sequence.
+     * @param count - The number of elements to take.
+     * @returns A new Enumerable containing the taken elements.
+     */
+    take(count: number): Enumerable<T>;
+    /**
+     * Converts the sequence into an array.
+     * @returns An array containing all elements in the sequence.
+     */
+    toArray(): T[];
+    /**
+     * Converts the sequence into a Map using a key selector and optional value selector.
+     * @param keySelector - A function to extract the key from each element.
+     * @param valueSelector - A function to extract the value from each element. Defaults to the item itself.
+     * @returns A Map of key-value pairs.
+     */
+    toDictionary<TKey, TValue = T>(keySelector: (item: T) => TKey, valueSelector?: (item: T) => TValue): Map<TKey, TValue>;
+    /**
+     * Filters the sequence to include only elements that satisfy the predicate.
+     * @param predicate - A function to test each element for a condition.
+     * @returns A new Enumerable containing the filtered elements.
+     */
+    where(predicate: (item: T) => boolean): Enumerable<T>;
+    /**
+     * Returns a new Enumerable that yields each element of the sequence paired with its index.
+     *
+     * @returns An Enumerable of [element, index] tuples.
      *
      * @example
      * // Example usage with a for...of loop:
@@ -333,26 +619,7 @@ export declare class Enumerable<T> {
      * console.log(indexed);
      * // Output: [['x', 0], ['z', 2]]
      */
-    withIndex(): IterableIterator<[T, number]>;
-    /**
- * Filters the sequence and returns only elements of the specified type.
- * @template U The target type to filter by.
- * @param typeCheck - A runtime check function to validate the type of each element.
- * @returns A new Enumerable containing elements of type `U`.
- *
- * @example
- * const mixed: Enumerable<unknown> = Enumerable.from([1, "hello", true, 42]);
- * const numbers = mixed.ofType<number>(item => typeof item === "number");
- * console.log(numbers.toArray()); // Outputs: [1, 42]
- *
- * @example
- * class Animal {}
- * class Dog extends Animal {}
- * const animals: Enumerable<Animal> = Enumerable.from([new Animal(), new Dog()]);
- * const dogs = animals.ofType<Dog>(item => item instanceof Dog);
- * console.log(dogs.toArray()); // Outputs: [Dog instance]
- */
-    ofType<U extends T>(typeCheck: (item: T) => item is U): Enumerable<U>;
+    withIndex(): Enumerable<[T, number]>;
 }
 declare class OrderedEnumerable<T> extends Enumerable<T> {
     private readonly sortComparers;
@@ -378,4 +645,8 @@ declare class OrderedEnumerable<T> extends Enumerable<T> {
      */
     [Symbol.iterator](): Iterator<T>;
 }
+export declare class GroupedEnumerable<TKey, TElement> extends Enumerable<TElement> {
+    readonly key: TKey;
+    constructor(key: TKey, elements: Iterable<TElement>);
+}
 export {};

package/types/Utility/objectUtils.d.ts

@@ -33,3 +33,23 @@ export declare function toListItemBagList(obj: Record<string, unknown>): ListIte
  * if no such path exists.
  */
 export declare function getValueFromPath(object: Record<string, unknown>, path: string): unknown;
+/**
+ * Gets the member name of a type.
+ *
+ * This is useful for ensuring that the property name is valid and exists on the type.
+ *
+ * @param memberName The member name to get. This should be a key of the type `T`.
+ * @template T The type to get the member name from.
+ * @returns The member name as a key of the type `T`.
+ */
+export declare function getTypeMemberName<T, K extends keyof T>(memberName: K): K;
+/**
+ * Returns a function to get the member name of a type.
+ *
+ * @example
+ * const getMemberName = useGetTypeMemberName<MyType>();
+ * const memberName = getMemberName("myProperty"); // returns "myProperty" as a key of MyType
+ *
+ * @returns A function that takes a member name and returns it as a key of the type `T`.
+ */
+export declare function useGetTypeMemberName<T>(): <K extends keyof T>(memberName: K) => K;

package/types/Utility/rockDateTime.d.ts

@@ -165,6 +165,22 @@ export declare class RockDateTime {
      * @returns A new instance of RockDateTime that represents the new date and time.
      */
     addDays(days: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the first millisecond
+     * of the start of the week for this instance.
+     *
+     * @example
+     * new Date(2014, 2, 6).startOf("week").toISOString(); //=> '2014-03-03T00:00:00.000-05:00', weeks always start on Mondays
+     */
+    startOfWeek(): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the first millisecond
+     * of the start of the month for this instance.
+     *
+     * @example
+     * new Date(2014, 2, 6).startOf("month").toISOString(); //=> '2014-03-01T00:00:00.000-05:00'
+     */
+    startOfMonth(): RockDateTime;
     /**
      * Creates a new RockDateTime instance that represents the last millisecond
      * of the end of the month for this instance.
@@ -270,7 +286,7 @@ export declare class RockDateTime {
      * Transforms the date into a human friendly elapsed time string.
      *
      * @example
-     * // Returns "21yrs"
+     * // Returns "25 Years Ago" if the current date is 2025-03-04 and this instance is 2000-03-04.
      * RockDateTime.fromParts(2000, 3, 4).toElapsedString();
      *
      * @returns A string that represents the amount of time that has elapsed.
@@ -323,6 +339,7 @@ export declare class RockDateTime {
      * @returns True if this instance represents a point in time that occurred before another point in time, regardless of time zone.
      */
     isEarlierThan(otherDateTime: RockDateTime): boolean;
+    compareTo(otherDateTime: RockDateTime): number;
     /**
      * Obsolete. Use toElapsedString instead.
      * Calculates the elapsed time between this date and the reference date and
@@ -340,3 +357,4 @@ export declare class RockDateTime {
      */
     totalMonths(otherDateTime: RockDateTime): number;
 }
+export declare function compareRockDateTimes(a: RockDateTime, b: RockDateTime): number;

package/types/Utility/rockTimeSpan.d.ts

@@ -0,0 +1,30 @@
+export declare class RockTimeSpan {
+    private _milliseconds;
+    constructor(_milliseconds: number);
+    static fromMilliseconds(milliseconds: number): RockTimeSpan;
+    static fromSeconds(seconds: number): RockTimeSpan;
+    static fromMinutes(minutes: number): RockTimeSpan;
+    static fromHours(hours: number): RockTimeSpan;
+    static fromDays(days: number): RockTimeSpan;
+    get totalMilliseconds(): number;
+    get totalSeconds(): number;
+    get totalMinutes(): number;
+    get totalHours(): number;
+    get totalDays(): number;
+    get approximatedTotalMonths(): number;
+    get milliseconds(): number;
+    get seconds(): number;
+    get minutes(): number;
+    get hours(): number;
+    get days(): number;
+    /**
+     * Transforms the date into a human friendly elapsed time string.
+     *
+     * @example
+     * // Returns "25 Years Ago" if the current date is 2025-03-04 and this instance is 2000-03-04.
+     * RockDateTime.fromParts(2000, 3, 4).toElapsedString();
+     *
+     * @returns A string that represents the amount of time that has elapsed.
+     */
+    toElapsedString(): string;
+}

package/types/Utility/stringUtils.d.ts

@@ -170,6 +170,19 @@ export declare function createHashSha256(str: string): Promise<string>;
  * @param replace The string to replace with.
  */
 export declare function replaceAll(str: string, search: string, replace: string): string;
+/**
+ * Attempts to parse the JSON and returns undefined if it could not be parsed.
+ *
+ * @param value The JSON value to parse.
+ *
+ * @returns The object that represents the JSON or undefined.
+ */
+export declare function safeParseJson<T>(value: string | null | undefined): T | undefined;
+/**
+ * Returns a string like "an apple" or "a banana" based on the initial sound of the word.
+ * Handles common English edge cases, including silent 'h' and hard 'u' sounds.
+ */
+export declare function prependSingularIndefiniteArticle(singularWord: string): string;
 declare const _default: {
     asCommaAnd: typeof asCommaAnd;
     containsHtmlTag: typeof containsHtmlTag;
@@ -188,5 +201,6 @@ declare const _default: {
     truncate: typeof truncate;
     createHash: typeof createHash;
     replaceAll: typeof replaceAll;
+    safeParseJson: typeof safeParseJson;
 };
 export default _default;

package/types/Utility/tooltip.d.ts

@@ -39,5 +39,18 @@ export declare function hideTooltip(node: Element): void;
  *
  * @param node The node for which to destroy a tooltip.
  */
-export declare function destroyTooltip(node: Element): void;
+export declare function destroyTooltip(node: Element | Element[]): void;
+/**
+ * Reset a tooltip by destroying the existing one and adding a new tooltip on
+ *
+ * @param node The node or nodes to have tooltips configured on.
+ * @param options The options that describe how the tooltips should behave.
+ */
+export declare function resetTooltip(node: Element | Element[], options?: TooltipOptions): Promise<void>;
+/**
+ * Applies a tooltip to an element. The element should have an `data-original-title` attribute containing the tooltip text.
+ *
+ * Typical use, `:ref="applyTooltip"`
+ */
+export declare function applyTooltip(el: unknown, options?: TooltipOptions): void;
 export {};

package/types/Utility/treeItemProviders.d.ts

@@ -106,7 +106,7 @@ export declare class LocationTreeItemProvider implements ITreeItemProvider {
     /**
      * @inheritdoc
      */
-    getRootItems(): Promise<TreeItemBag[]>;
+    getRootItems(expandToValues: string[]): Promise<TreeItemBag[]>;
     /**
      * @inheritdoc
      */

package/types/Utility/util.d.ts

@@ -71,4 +71,8 @@ export declare function isNullish(value: unknown): value is null | undefined;
  * Returns `true` if the value is not `null` or `undefined` (nullish).
  */
 export declare function isNotNullish<T>(item: T): item is NonNullable<T>;
+/**
+ * Blindly asserts that the value is of type T.
+ */
+export declare function assertType<T>(value: unknown): value is T;
 export {};