@fgv/ts-utils 5.0.2 → 5.1.0-0

package/lib/packlets/collections/collector.d.ts

@@ -30,6 +30,7 @@ export interface IReadOnlyCollector<TITEM extends ICollectible<any, any>> extend
  * @public
  */
 export interface ICollectorConstructorParams<TITEM extends ICollectible<any, any>> {
+    /** Optional initial items to populate the collector. */
     items?: TITEM[];
 }
 /**
@@ -45,7 +46,7 @@ export declare class Collector<TITEM extends ICollectible<any, any>> implements
     private readonly _byKey;
     private readonly _byIndex;
     /**
-     * {@inheritdoc Collections.ResultMap.size}
+     * {@inheritDoc Collections.ResultMap.size}
      */
     get size(): number;
     /**
@@ -72,19 +73,19 @@ export declare class Collector<TITEM extends ICollectible<any, any>> implements
      */
     add(item: TITEM): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.entries}
+     * {@inheritDoc Collections.ResultMap.entries}
      */
     entries(): IterableIterator<KeyValueEntry<CollectibleKey<TITEM>, TITEM>>;
     /**
-     * {@inheritdoc Collections.ResultMap.forEach}
+     * {@inheritDoc Collections.ResultMap.forEach}
      */
     forEach(callback: ResultMapForEachCb<CollectibleKey<TITEM>, TITEM>, arg?: unknown): void;
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key: CollectibleKey<TITEM>): DetailedResult<TITEM, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.IReadOnlyCollector.getAt}
+     * {@inheritDoc Collections.IReadOnlyCollector.getAt}
      */
     getAt(index: number): Result<TITEM>;
     /**
@@ -101,7 +102,7 @@ export declare class Collector<TITEM extends ICollectible<any, any>> implements
      * Gets an existing item with a key matching the supplied key, or adds a new item to the collector
      * using a factory callback if no item with that key exists.
      * @param key - The key of the item to add.
-     * @param callback - The factory callback to create the item.
+     * @param factory - The factory callback to create the item.
      * @returns Returns {@link DetailedSuccess | Success} with the item stored in the collector -
      * detail `exists` indicates that an existing item return and detail `added` indicates that the
      * item was added. Returns {@link DetailedFailure | Failure} with an error and appropriate
@@ -109,19 +110,19 @@ export declare class Collector<TITEM extends ICollectible<any, any>> implements
      */
     getOrAdd(key: CollectibleKey<TITEM>, factory: CollectibleFactoryCallback<TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: CollectibleKey<TITEM>): boolean;
     /**
-     * {@inheritdoc Collections.ResultMap.keys}
+     * {@inheritDoc Collections.ResultMap.keys}
      */
     keys(): IterableIterator<CollectibleKey<TITEM>>;
     /**
-     * {@inheritdoc Collections.ResultMap.values}
+     * {@inheritDoc Collections.ResultMap.values}
      */
     values(): IterableIterator<TITEM>;
     /**
-     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     * {@inheritDoc Collections.IReadOnlyCollector.valuesByIndex}
      */
     valuesByIndex(): ReadonlyArray<TITEM>;
     /**

package/lib/packlets/collections/collector.js

@@ -34,7 +34,7 @@ const base_1 = require("../base");
  */
 class Collector {
     /**
-     * {@inheritdoc Collections.ResultMap.size}
+     * {@inheritDoc Collections.ResultMap.size}
      */
     get size() {
         return this._byIndex.length;
@@ -90,13 +90,13 @@ class Collector {
         return (0, base_1.succeedWithDetail)(item, 'added');
     }
     /**
-     * {@inheritdoc Collections.ResultMap.entries}
+     * {@inheritDoc Collections.ResultMap.entries}
      */
     entries() {
         return this._byKey.entries();
     }
     /**
-     * {@inheritdoc Collections.ResultMap.forEach}
+     * {@inheritDoc Collections.ResultMap.forEach}
      */
     forEach(callback, arg) {
         for (const [key, value] of this._byKey.entries()) {
@@ -104,14 +104,14 @@ class Collector {
         }
     }
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key) {
         const item = this._byKey.get(key);
         return item ? (0, base_1.succeedWithDetail)(item, 'exists') : (0, base_1.failWithDetail)(`${key}: not found`, 'not-found');
     }
     /**
-     * {@inheritdoc Collections.IReadOnlyCollector.getAt}
+     * {@inheritDoc Collections.IReadOnlyCollector.getAt}
      */
     getAt(index) {
         if (typeof index !== 'number') {
@@ -149,25 +149,25 @@ class Collector {
         });
     }
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key) {
         return this._byKey.has(key);
     }
     /**
-     * {@inheritdoc Collections.ResultMap.keys}
+     * {@inheritDoc Collections.ResultMap.keys}
      */
     keys() {
         return this._byKey.keys();
     }
     /**
-     * {@inheritdoc Collections.ResultMap.values}
+     * {@inheritDoc Collections.ResultMap.values}
      */
     values() {
         return this._byKey.values();
     }
     /**
-     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     * {@inheritDoc Collections.IReadOnlyCollector.valuesByIndex}
      */
     valuesByIndex() {
         return this._byIndex;

package/lib/packlets/collections/collectorValidator.d.ts

@@ -12,19 +12,19 @@ import { CollectibleKey, ICollectible } from './collectible';
  */
 export interface IReadOnlyCollectorValidator<TITEM extends ICollectible<any, any>> extends IReadOnlyResultMapValidator<CollectibleKey<TITEM>, TITEM> {
     /**
-     * {@inheritdoc Collections.ConvertingCollectorValidator.map}
+     * {@inheritDoc Collections.ReadOnlyResultMapValidator.map}
      */
     readonly map: IReadOnlyResultMap<CollectibleKey<TITEM>, TITEM>;
     /**
-     * {@inheritdoc Collections.Collector.get}
+     * {@inheritDoc Collections.Collector.get}
      */
     get(key: string): DetailedResult<TITEM, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: string): boolean;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:2)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      */
     getOrAdd(key: string, factory: ResultMapValueFactory<CollectibleKey<TITEM>, TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
 }
@@ -33,7 +33,9 @@ export interface IReadOnlyCollectorValidator<TITEM extends ICollectible<any, any
  * @public
  */
 export interface ICollectorValidatorCreateParams<TITEM extends ICollectible<any, any>> {
+    /** The collector to validate access to. */
     readonly collector: Collector<TITEM>;
+    /** The key-value converters for validation. */
     readonly converters: KeyValueConverters<CollectibleKey<TITEM>, TITEM>;
 }
 /**
@@ -51,28 +53,28 @@ export declare class CollectorValidator<TITEM extends ICollectible<any, any>> im
      */
     constructor(params: ICollectorValidatorCreateParams<TITEM>);
     /**
-     * {@inheritdoc Collections.Collector.add}
+     * {@inheritDoc Collections.Collector.add}
      */
     add(item: unknown): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.get}
+     * {@inheritDoc Collections.Collector.get}
      */
     get(key: string): DetailedResult<TITEM, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:2)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      */
     getOrAdd(key: string, factory: ResultMapValueFactory<CollectibleKey<TITEM>, TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:1)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      * @param item - The item to add to the collector.
      */
     getOrAdd(item: unknown): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: string): boolean;
     /**
-     * {@inheritdoc Collections.Collector.toReadOnly}
+     * {@inheritDoc Collections.Collector.toReadOnly}
      */
     toReadOnly(): IReadOnlyCollectorValidator<TITEM>;
     /**

package/lib/packlets/collections/collectorValidator.js

@@ -40,7 +40,7 @@ class CollectorValidator {
         this.converters = params.converters;
     }
     /**
-     * {@inheritdoc Collections.Collector.add}
+     * {@inheritDoc Collections.Collector.add}
      */
     add(item) {
         return this._convertValue(item).onSuccess((i) => {
@@ -48,7 +48,7 @@ class CollectorValidator {
         });
     }
     /**
-     * {@inheritdoc Collections.Collector.get}
+     * {@inheritDoc Collections.Collector.get}
      */
     get(key) {
         return this.converters.convertKey(key).onSuccess((k) => {
@@ -67,13 +67,13 @@ class CollectorValidator {
         }
     }
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key) {
         return this._collector.has(key);
     }
     /**
-     * {@inheritdoc Collections.Collector.toReadOnly}
+     * {@inheritDoc Collections.Collector.toReadOnly}
      */
     toReadOnly() {
         return this;

package/lib/packlets/collections/converters.d.ts

@@ -0,0 +1,18 @@
+import { Converter } from '../conversion';
+import { KeyValueEntry } from './common';
+/**
+ * Initialization parameters for the {@link Collections.Converters.keyValueEntry | keyValueEntry} converter.
+ * @public
+ */
+export interface IKeyValueEntryConverterParams<TK extends string, TV> {
+    key: Converter<TK, unknown>;
+    value: Converter<TV, unknown>;
+}
+/**
+ * A {@link Converter | Converter} for {@link Collections.KeyValueEntry | KeyValueEntry} instances.
+ * @param params - Conversion parameters.
+ * @returns A converter for which validates key value entries using the supplied validators.
+ * @public
+ */
+export declare function keyValueEntry<TK extends string, TV>(params: IKeyValueEntryConverterParams<TK, TV>): Converter<KeyValueEntry<TK, TV>, unknown>;
+//# sourceMappingURL=converters.d.ts.map

package/lib/packlets/collections/converters.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyValueEntry = keyValueEntry;
+const base_1 = require("../base");
+const conversion_1 = require("../conversion");
+/**
+ * A {@link Converter | Converter} for {@link Collections.KeyValueEntry | KeyValueEntry} instances.
+ * @param params - Conversion parameters.
+ * @returns A converter for which validates key value entries using the supplied validators.
+ * @public
+ */
+function keyValueEntry(params) {
+    return conversion_1.Converters.generic((from) => {
+        return params.key.convert(from).onSuccess((key) => {
+            return params.value.convert(from).onSuccess((value) => {
+                return base_1.Success.with([key, value]);
+            });
+        });
+    });
+}
+//# sourceMappingURL=converters.js.map

package/lib/packlets/collections/convertingCollector.d.ts

@@ -37,7 +37,7 @@ export declare class ConvertingCollector<TITEM extends ICollectible<any, any>, T
      */
     static createConvertingCollector<TITEM extends ICollectible<any, any>, TSRC = TITEM>(params: IConvertingCollectorConstructorParams<TITEM, TSRC>): Result<ConvertingCollector<TITEM, TSRC>>;
     /**
-     * {@inheritdoc Collections.Collector.add}
+     * {@inheritDoc Collections.Collector.add}
      */
     add(item: TITEM): DetailedResult<TITEM, CollectorResultDetail>;
     /**
@@ -54,17 +54,17 @@ export declare class ConvertingCollector<TITEM extends ICollectible<any, any>, T
      * Adds an item to the collector using a supplied {@link Collections.CollectibleFactoryCallback | factory callback}
      * at a specified key, failing if an item with that key already exists or if the created item is invalid.
      * @param key - The key of the item to add.
-     * @param callback - The factory callback to create the item.
+     * @param cb - The factory callback to create the item.
      * @returns Returns {@link Success | Success} with the item if it is added, or {@link Failure | Failure} with
      * an error if the item cannot be created and indexed.
      */
     add(key: CollectibleKey<TITEM>, cb: CollectibleFactoryCallback<TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:1)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      */
     getOrAdd(item: TITEM): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:2)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      */
     getOrAdd(key: CollectibleKey<TITEM>, callback: CollectibleFactoryCallback<TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**

package/lib/packlets/collections/convertingCollectorValidator.d.ts

@@ -11,7 +11,9 @@ import { IReadOnlyCollectorValidator } from './collectorValidator';
  * @public
  */
 export interface IConvertingCollectorValidatorCreateParams<TITEM extends ICollectible<any, any>, TSRC = TITEM> {
+    /** The converting collector to validate access to. */
     collector: ConvertingCollector<TITEM, TSRC>;
+    /** The key-value converters for validation. */
     converters: KeyValueConverters<CollectibleKey<TITEM>, TSRC>;
 }
 /**
@@ -30,31 +32,32 @@ export declare class ConvertingCollectorValidator<TITEM extends ICollectible<any
      */
     constructor(params: IConvertingCollectorValidatorCreateParams<TITEM, TSRC>);
     /**
-     * {@inheritdoc Collections.ConvertingCollector.(add:1)}
+     * {@inheritDoc Collections.ConvertingCollector.add}
      */
     add(key: string, value: unknown): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.ConvertingCollector.(add:2)}
+     * Adds an item to the collector using a supplied factory callback
+     * at a specified key, validating the key first.
      */
     add(key: string, factory: ResultMapValueFactory<CollectibleKey<TITEM>, TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.get}
+     * {@inheritDoc Collections.Collector.get}
      */
     get(key: string): DetailedResult<TITEM, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ConvertingCollector.(getOrAdd:3)}
+     * {@inheritDoc Collections.ConvertingCollector.getOrAdd}
      */
     getOrAdd(key: string, value: unknown): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.Collector.(getOrAdd:2)}
+     * {@inheritDoc Collections.Collector.getOrAdd}
      */
     getOrAdd(key: string, factory: ResultMapValueFactory<CollectibleKey<TITEM>, TITEM>): DetailedResult<TITEM, CollectorResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: string): boolean;
     /**
-     * {@inheritdoc Collections.Collector.toReadOnly}
+     * {@inheritDoc Collections.Collector.toReadOnly}
      */
     toReadOnly(): IReadOnlyCollectorValidator<TITEM>;
     /**

package/lib/packlets/collections/convertingCollectorValidator.js

@@ -48,7 +48,7 @@ class ConvertingCollectorValidator {
         return this.getOrAdd(key, valueOrFactory);
     }
     /**
-     * {@inheritdoc Collections.Collector.get}
+     * {@inheritDoc Collections.Collector.get}
      */
     get(key) {
         return this.converters.convertKey(key).onSuccess((k) => {
@@ -73,13 +73,13 @@ class ConvertingCollectorValidator {
         }
     }
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key) {
         return this._collector.has(key);
     }
     /**
-     * {@inheritdoc Collections.Collector.toReadOnly}
+     * {@inheritDoc Collections.Collector.toReadOnly}
      */
     toReadOnly() {
         return this;

package/lib/packlets/collections/convertingResultMap.d.ts

@@ -0,0 +1,176 @@
+import { DetailedResult, Result } from '../base';
+import { KeyValueEntry } from './common';
+import { IReadOnlyResultMap, ResultMapForEachCb, ResultMapResultDetail } from './readonlyResultMap';
+import { ReadOnlyConvertingResultMap, ConvertingResultMapValueConverter } from './readOnlyConvertingResultMap';
+import { IResultMap, ResultMapValueFactory } from './resultMap';
+/**
+ * Parameters for constructing a {@link Collections.ConvertingResultMap | ConvertingResultMap}.
+ * @public
+ */
+export interface IConvertingResultMapConstructorParams<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>> {
+    /**
+     * The inner map containing source values.
+     */
+    inner: TSRCMAP;
+    /**
+     * The converter function to transform source values to target values.
+     */
+    converter: ConvertingResultMapValueConverter<TK, TSRC, TTARGET>;
+}
+/**
+ * A wrapper around a mutable result map that invalidates cache entries
+ * in the parent {@link Collections.ConvertingResultMap | ConvertingResultMap} when mutations occur.
+ * @public
+ */
+export declare class CacheInvalidatingResultMapWrapper<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>> implements IResultMap<TK, TSRC> {
+    private readonly _inner;
+    private readonly _parent;
+    /**
+     * Constructs a new cache-invalidating wrapper.
+     * @param inner - The inner map to wrap.
+     * @param parent - The parent converting map whose cache should be invalidated.
+     */
+    constructor(inner: TSRCMAP, parent: ConvertingResultMap<TK, TSRC, TTARGET, TSRCMAP>);
+    /**
+     * The number of entries in the map.
+     */
+    get size(): number;
+    /**
+     * Adds a key/value pair to the map if the key does not already exist.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to add.
+     * @param value - The value to add.
+     * @returns The result of the add operation.
+     */
+    add(key: TK, value: TSRC): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Sets a key/value pair in the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to set.
+     * @param value - The value to set.
+     * @returns The result of the set operation.
+     */
+    set(key: TK, value: TSRC): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Updates an existing key in the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to update.
+     * @param value - The new value.
+     * @returns The result of the update operation.
+     */
+    update(key: TK, value: TSRC): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Deletes a key from the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to delete.
+     * @returns The result of the delete operation.
+     */
+    delete(key: TK): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map.
+     * @param key - The key to retrieve.
+     * @returns The result of the get operation.
+     */
+    get(key: TK): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map, or adds a supplied value if it does not exist.
+     * Invalidates the cache entry for the key if a new value is added.
+     * @param key - The key to retrieve or add.
+     * @param value - The value to add if the key does not exist.
+     * @returns The result of the operation.
+     */
+    getOrAdd(key: TK, value: TSRC): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map, or adds a value created by a factory if it does not exist.
+     * Invalidates the cache entry for the key if a new value is added.
+     * @param key - The key to retrieve or add.
+     * @param factory - A factory function to create the value if the key does not exist.
+     * @returns The result of the operation.
+     */
+    getOrAdd(key: TK, factory: ResultMapValueFactory<TK, TSRC>): DetailedResult<TSRC, ResultMapResultDetail>;
+    /**
+     * Checks if the map contains a key.
+     * @param key - The key to check.
+     * @returns `true` if the key exists, `false` otherwise.
+     */
+    has(key: TK): boolean;
+    /**
+     * Clears all entries from the map.
+     * Clears the entire cache.
+     */
+    clear(): void;
+    /**
+     * Returns an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    entries(): IterableIterator<KeyValueEntry<TK, TSRC>>;
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys(): IterableIterator<TK>;
+    /**
+     * Returns an iterator over the map values.
+     * @returns An iterator over the map values.
+     */
+    values(): IterableIterator<TSRC>;
+    /**
+     * Calls a callback for each entry in the map.
+     * @param cb - The callback to call for each entry.
+     * @param thisArg - Optional `this` argument for the callback.
+     */
+    forEach(cb: ResultMapForEachCb<TK, TSRC>, thisArg?: unknown): void;
+    /**
+     * Gets an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    [Symbol.iterator](): IterableIterator<KeyValueEntry<TK, TSRC>>;
+    /**
+     * Gets a read-only version of this map.
+     * @returns A read-only version of this map.
+     */
+    toReadOnly(): IReadOnlyResultMap<TK, TSRC>;
+}
+/**
+ * A result map that wraps an inner {@link Collections.IResultMap | IResultMap} of source type
+ * and returns lazily-converted, cached values of a target type. Exposes the inner map
+ * via a {@link Collections.CacheInvalidatingResultMapWrapper | source} property that
+ * invalidates cache entries when mutations occur.
+ * @public
+ */
+export declare class ConvertingResultMap<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>> extends ReadOnlyConvertingResultMap<TK, TSRC, TTARGET> {
+    /**
+     * A wrapper around the inner map that invalidates cache entries when mutations occur.
+     * Use this property to add, update, or delete source values.
+     */
+    readonly source: CacheInvalidatingResultMapWrapper<TK, TSRC, TTARGET, TSRCMAP>;
+    /**
+     * The inner map, typed as the specific source map type.
+     */
+    protected readonly _typedInner: TSRCMAP;
+    /**
+     * Constructs a new {@link Collections.ConvertingResultMap | ConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params: IConvertingResultMapConstructorParams<TK, TSRC, TTARGET, TSRCMAP>);
+    /**
+     * Creates a new {@link Collections.ConvertingResultMap | ConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>>(params: IConvertingResultMapConstructorParams<TK, TSRC, TTARGET, TSRCMAP>): Result<ConvertingResultMap<TK, TSRC, TTARGET, TSRCMAP>>;
+    /**
+     * Clears a single entry from the cache.
+     * This method is public to allow the cache-invalidating wrapper to call it.
+     * @param key - The key to clear from the cache.
+     * @internal
+     */
+    _clearCacheEntry(key: TK): void;
+    /**
+     * Clears all entries from the cache.
+     * This method is public to allow the cache-invalidating wrapper to call it.
+     * @internal
+     */
+    _clearCache(): void;
+}
+//# sourceMappingURL=convertingResultMap.d.ts.map