@fgv/ts-utils 5.0.1-0 → 5.0.1-10

package/dist/test/helpers/jest/matchers/toSucceedAndMatchInlineSnapshot/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchInlineSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchInlineSnapshot';
+export default {
+    toSucceedAndMatchInlineSnapshot: function (received, snapshot) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchInlineSnapshot.call(context, received.value, {}, snapshot);
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndMatchSnapshot/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchSnapshot';
+export default {
+    toSucceedAndMatchSnapshot: function (received) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchSnapshot.call(context, received.value, 'toSucceedAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndSatisfy/index.js

@@ -0,0 +1,53 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received) {
+    const expected = 'successful callback';
+    const got = [printReceivedResult(received)];
+    got.push('  Callback returned true');
+    return () => [
+        matcherHint(`.not.${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', false, expected),
+        ...got
+    ].join('\n');
+}
+function failMessage(received, cbResult) {
+    const expected = 'successful callback';
+    const got = [printReceivedResult(received)];
+    /* c8 ignore else */
+    if (cbResult.isFailure()) {
+        got.push(cbResult.message);
+    }
+    else if (cbResult.value === false) {
+        got.push('  Callback returned false');
+    }
+    else if (cbResult.value === undefined) {
+        /* c8 ignore else */
+        got.push('  Callback was not invoked');
+    }
+    else {
+        /* c8 ignore next */
+        throw new Error('Internal error: toSucceedAndSatisfy.failMessage passed success with true');
+    }
+    return () => [
+        matcherHint(`${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', true, expected),
+        ...got
+    ].join('\n');
+}
+export default {
+    toSucceedAndSatisfy: function (received, test) {
+        // For the normal (not '.not') case, we do not want to capture exceptions
+        // so that the IDE can display exactly the line on which the failure case.
+        // For the .not case, we want to swallow exceptions or expect failures since
+        // we're just testing failure and not the reason.
+        const capture = this.isNot;
+        const cbResult = predicate(received, test, !!capture);
+        const pass = cbResult.isSuccess() && cbResult.value === true;
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received, cbResult) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndSatisfy/predicate.js

@@ -0,0 +1,17 @@
+import { captureResult, fail, succeed } from '../../ts-utils';
+export const matcherName = 'toSucceedAndSatisfy';
+// If the result is successful and callback does not throw, returns Success with the callback return value, or
+//    true if the callback returns undefined
+// If the result is successful but the callback throws, returns Failure with the thrown error
+// If the result is failure, returns Success with undefined
+export function predicate(received, cb, capture) {
+    if (received.isSuccess()) {
+        const cbResult = capture ? captureResult(() => cb(received.value)) : succeed(cb(received.value));
+        if (cbResult.isSuccess()) {
+            return succeed(cbResult.value === true || cbResult.value === undefined);
+        }
+        return fail(`  Callback failed with:\n    ${cbResult.message}`);
+    }
+    return succeed(undefined);
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/matchers/toSucceedWith/index.js

@@ -0,0 +1,27 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('success', false, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedResult('success', true, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWith: function (received, expected) {
+        const pass = predicate(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedWith/predicate.js

@@ -0,0 +1,12 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWith';
+export function predicate(received, expected) {
+    if (received.isSuccess()) {
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            return expected.test(received.value);
+        }
+        return equals(received.value, expected);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/matchers/toSucceedWithDetail/index.js

@@ -0,0 +1,27 @@
+import { printExpectedDetailedResult, printReceivedDetailedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedDetailedResult('success', false, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedDetailedResult('success', true, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWithDetail: function (received, expected, detail) {
+        const pass = predicate(received, expected, detail);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected, detail) };
+        }
+        return { pass: false, message: failMessage(received, expected, detail) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedWithDetail/predicate.js

@@ -0,0 +1,17 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWithDetail';
+export function predicate(received, expected, detail) {
+    if (received.isSuccess()) {
+        let pass = false;
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            pass = expected.test(received.value);
+        }
+        else {
+            pass = equals(received.value, expected);
+        }
+        pass = pass && equals(received.detail, detail);
+        return pass;
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/resolvers/cli.js

@@ -0,0 +1,10 @@
+import * as Resolver from '../utils/snapshotResolver';
+export const CLI_SNAPSHOT_FOLDER = '__cli__';
+export function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+export function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+export const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=cli.js.map

package/dist/test/helpers/jest/resolvers/ide.js

@@ -0,0 +1,10 @@
+import * as Resolver from '../utils/snapshotResolver';
+export const CLI_SNAPSHOT_FOLDER = '__ide__';
+export function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+export function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+export const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=ide.js.map

package/dist/test/helpers/jest/ts-utils.js

@@ -0,0 +1,2 @@
+export * from '../../../index';
+//# sourceMappingURL=ts-utils.js.map

package/dist/test/helpers/jest/types/index.js

@@ -0,0 +1,3 @@
+/// <reference types="jest"/>
+export {};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/utils/matcherHelpers.js

@@ -0,0 +1,47 @@
+import { printExpected, printReceived } from 'jest-matcher-utils';
+function printExpectedValue(outcome, expected) {
+    return expected !== undefined ? `  ${outcome} with ${printExpected(expected)}` : `  ${outcome}`;
+}
+export function printExpectedResult(expect, isNot, expected) {
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expected)
+                : printExpectedValue('Failure', expected)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expected)
+                : printExpectedValue('Not failure', expected)
+    ].join('\n');
+}
+export function printExpectedDetailedResult(expect, isNot, expectedMessage, expectedDetail) {
+    /* c8 ignore next */
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expectedMessage)
+                : printExpectedValue('Failure', expectedMessage)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expectedMessage)
+                : printExpectedValue('Not failure', expectedMessage),
+        `  Detail: "${printExpected(expectedDetail)}"`
+    ].join('\n');
+}
+export function printReceivedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with ${printReceived(received.value)}`
+            : `  Failure with "${received.message}"`
+    ].join('\n');
+}
+export function printReceivedDetailedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with "${printReceived(received.value)}"\n  Detail: "${printReceived(received.detail)}"`
+            : `  Failure with "${received.message}"\n  Detail: "${printReceived(received.detail)}"`
+    ].join('\n');
+}
+//# sourceMappingURL=matcherHelpers.js.map

package/dist/test/helpers/jest/utils/snapshotResolver.js

@@ -0,0 +1,11 @@
+import path from 'path';
+export function resolveSnapshotPath(testPath, snapshotExtension, snapshotFolderName) {
+    const snapshotPath = path.join(path.join(path.dirname(testPath), '__snapshots__', snapshotFolderName), path.basename(testPath) + snapshotExtension);
+    return snapshotPath;
+}
+export function resolveTestPath(snapshotFilePath, snapshotExtension) {
+    const testPath = path.join(path.dirname(path.dirname(path.dirname(snapshotFilePath))), path.basename(snapshotFilePath, snapshotExtension));
+    return testPath;
+}
+export const testPathForConsistencyCheck = path.posix.join('consistency_check', '__tests__', 'subdir', 'example.test.js');
+//# sourceMappingURL=snapshotResolver.js.map

package/dist/test/unit/collections/helpers.js

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+import { captureResult, succeed } from '../../../packlets/base';
+import { Collectible, ConvertingCollector } from '../../../packlets/collections';
+import { Converters } from '../../../packlets/conversion';
+export const testThingKey = Converters.string
+    .withConstraint((s) => /^thing\d{1,4}$/.test(s))
+    .withFormattedError((val) => `${val} is invalid TestThingKey`)
+    .withBrand('TestThingKey');
+export const testThingIndex = Converters.number
+    .withConstraint((n) => n >= 0)
+    .withBrand('TestThingIndex');
+export const testThing = Converters.strictObject({
+    str: Converters.string.optional(),
+    num: Converters.number.optional(),
+    bool: Converters.boolean.optional()
+});
+export class BrandedCollectibleTestThing extends Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: testThingIndex });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return testThingKey.convert(key).onSuccess((convertedKey) => {
+            return testThingIndex.convert(index).onSuccess((convertedIndex) => {
+                return captureResult(() => new BrandedCollectibleTestThing(thing, convertedKey, convertedIndex));
+            });
+        });
+    }
+}
+export class CollectibleTestThing extends Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: Converters.number });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return captureResult(() => new CollectibleTestThing(thing, key, index));
+    }
+}
+export class BrokenCollectibleTestThing extends CollectibleTestThing {
+    constructor(thing, key, index) {
+        super(thing, key, index ? (index + 1) : undefined);
+    }
+    setIndex(index) {
+        this._index = index + 1;
+        return succeed(this.index);
+    }
+}
+export class TestCollector extends ConvertingCollector {
+    constructor(things) {
+        const entries = things
+            ? { entries: things.map((thing, index) => [`thing${index}`, thing]) }
+            : {};
+        const params = Object.assign({ factory: TestCollector._factory }, entries);
+        super(params);
+    }
+    static _factory(key, index, item) {
+        return succeed(new CollectibleTestThing(item, key, index));
+    }
+}
+export function getTestThings() {
+    const things = [
+        { str: 'thing0', num: 0, bool: false },
+        { str: 'thing1', num: 1, bool: true },
+        { str: 'thing2', num: 2, bool: false },
+        { str: 'thing3', num: 3, bool: true },
+        { str: 'thing4', num: 4, bool: false }
+    ];
+    const collectibles = things.map((thing, index) => new CollectibleTestThing(thing, `thing${index}`, index));
+    return { things, collectibles };
+}
+export function getBrandedTestThings() {
+    const things = [
+        { str: 'thing0', num: 0, bool: false },
+        { str: 'thing1', num: 1, bool: true },
+        { str: 'thing2', num: 2, bool: false },
+        { str: 'thing3', num: 3, bool: true },
+        { str: 'thing4', num: 4, bool: false }
+    ];
+    const collectibles = things.map((thing, index) => BrandedCollectibleTestThing.create(thing, `thing${index}`, index).orThrow());
+    return { things, collectibles };
+}
+//# sourceMappingURL=helpers.js.map

package/dist/test/unit/hashTextEncodeCompat.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ */
+import '../helpers/jest';
+import { Crc32Normalizer } from '../../packlets/hash';
+describe('Crc32Normalizer TextEncoder/Buffer compatibility', () => {
+    test('falls back to a non-TextEncoder path when TextEncoder is unavailable', () => {
+        const expected = Crc32Normalizer.crc32Hash(['hello']);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const g = globalThis;
+        const originalTextEncoder = g.TextEncoder;
+        try {
+            delete g.TextEncoder;
+            const actual = Crc32Normalizer.crc32Hash(['hello']);
+            expect(actual).toEqual(expected);
+        }
+        finally {
+            // Restore environment
+            g.TextEncoder = originalTextEncoder;
+        }
+    });
+});
+//# sourceMappingURL=hashTextEncodeCompat.js.map

package/dist/ts-utils.d.ts

@@ -1114,7 +1114,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               /**
                * {@inheritdoc IResult.report}
                */
-              report(reporter?: IResultReporter<T, TD>, options?: IResultReportOptions<TD>): this;
+              report(reporter?: IResultReporter<T, unknown>, options?: IResultReportOptions<unknown>): DetailedFailure<T, TD>;
               orThrow(logOrFormat?: IResultLogger<TD> | ErrorFormatter<TD>): never;
               orThrow(cb: ErrorFormatter): never;
               /**
@@ -1206,7 +1206,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               /**
                * {@inheritdoc IResult.report}
                */
-              report(reporter?: IResultReporter<T, TD>, options?: IResultReportOptions<TD>): this;
+              report(reporter?: IResultReporter<T, unknown>, options?: IResultReportOptions<unknown>): DetailedSuccess<T, TD>;
               /**
                * Creates a {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value and
                * optional detail.
@@ -1406,7 +1406,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               /**
                * {@inheritdoc IResult.report}
                */
-              report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+              report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Failure<T>;
               /**
                * Get a 'friendly' string representation of this object.
                * @remarks
@@ -1967,6 +1967,16 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               toString(separator?: string): string;
           }
 
+          /**
+           * Details for reporting a message.
+           * @public
+           */
+          export declare interface IMessageReportDetail<TD = unknown> {
+              level?: MessageLogLevel;
+              message?: ErrorFormatter<TD>;
+              detail?: TD;
+          }
+
           /**
            * Infers the type that will be returned by an instantiated converter.  Works
            * for complex as well as simple types.
@@ -2345,7 +2355,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                * @param reporter - The {@link IResultReporter | reporter} to which the result will be reported.
                * @param options - The {@link IResultReportOptions | options} for reporting the result.
                */
-              report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+              report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Result<T>;
           }
 
           /**
@@ -2382,7 +2392,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
            * @public
            */
           export declare interface IResultReporter<T, TD = unknown> {
-              reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+              reportSuccess(level: MessageLogLevel, value: T, detail?: TD, message?: ErrorFormatter<TD>): void;
               reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
           }
 
@@ -2394,15 +2404,11 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               /**
                * The level of reporting to be used for failure results.  Default is 'error'.
                */
-              failure?: MessageLogLevel;
+              failure?: MessageLogLevel | IMessageReportDetail<TD>;
               /**
                * The level of reporting to be used for success results.  Default is 'quiet'.
                */
-              success?: MessageLogLevel;
-              /**
-               * The error formatter to be used for reporting an error result.
-               */
-              message?: ErrorFormatter<TD>;
+              success?: MessageLogLevel | IMessageReportDetail<TD>;
           }
 
           /**
@@ -2681,10 +2687,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
            */
           declare class LogReporter<T, TD = unknown> implements ILogger, IResultReporter<T, TD> {
               /**
-               * The logger to wrap.
-               * @internal
+               * Base logger used to by this reporter.
+               * @public
                */
-              protected readonly _logger: ILogger;
+              readonly logger: ILogger;
               /**
                * The formatter to use for values.
                * @internal
@@ -2727,11 +2733,17 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
               /**
                * {@inheritDoc IResultReporter.reportSuccess}
                */
-              reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+              reportSuccess(level: MessageLogLevel, value: T, detail?: TD, message?: ErrorFormatter<TD>): void;
               /**
                * {@inheritDoc IResultReporter.reportFailure}
                */
               reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
+              /**
+               * Creates a new {@link Logging.LogReporter | LogReporter} with the same logger but a different value formatter.
+               * @param valueFormatter - The value formatter to use.
+               * @returns A new {@link Logging.LogReporter | LogReporter} with the same logger but a different value formatter.
+               */
+              withValueFormatter<TN>(valueFormatter: LogValueFormatter<TN, TD>): LogReporter<TN, TD>;
               /**
                * Generic method to try to format an object for logging.
                * @param value - The value to format.
@@ -4232,7 +4244,7 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                  /**
                                   * {@inheritdoc IResult.report}
                                   */
-                                 report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+                                 report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Success<T>;
                                  /**
                                   * Creates a {@link Success | Success<T>} with the supplied value.
                                   * @param value - The value to be returned.

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.52.12"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/packlets/base/result.d.ts

@@ -58,6 +58,15 @@ export interface IResultLogger<TD = unknown> {
  * @public
  */
 export type MessageLogLevel = 'quiet' | 'detail' | 'info' | 'warning' | 'error';
+/**
+ * Details for reporting a message.
+ * @public
+ */
+export interface IMessageReportDetail<TD = unknown> {
+    level?: MessageLogLevel;
+    message?: ErrorFormatter<TD>;
+    detail?: TD;
+}
 /**
  * Options for reporting a result.
  * @public
@@ -66,22 +75,18 @@ export interface IResultReportOptions<TD = unknown> {
     /**
      * The level of reporting to be used for failure results.  Default is 'error'.
      */
-    failure?: MessageLogLevel;
+    failure?: MessageLogLevel | IMessageReportDetail<TD>;
     /**
      * The level of reporting to be used for success results.  Default is 'quiet'.
      */
-    success?: MessageLogLevel;
-    /**
-     * The error formatter to be used for reporting an error result.
-     */
-    message?: ErrorFormatter<TD>;
+    success?: MessageLogLevel | IMessageReportDetail<TD>;
 }
 /**
  * Interface for reporting a result.
  * @public
  */
 export interface IResultReporter<T, TD = unknown> {
-    reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+    reportSuccess(level: MessageLogLevel, value: T, detail?: TD, message?: ErrorFormatter<TD>): void;
     reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
 }
 /**
@@ -286,7 +291,7 @@ export interface IResult<T> {
      * @param reporter - The {@link IResultReporter | reporter} to which the result will be reported.
      * @param options - The {@link IResultReportOptions | options} for reporting the result.
      */
-    report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+    report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Result<T>;
 }
 /**
  * Reports a successful {@link IResult | result} from some operation and the
@@ -376,7 +381,7 @@ export declare class Success<T> implements IResult<T> {
     /**
      * {@inheritdoc IResult.report}
      */
-    report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+    report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Success<T>;
     /**
      * Creates a {@link Success | Success<T>} with the supplied value.
      * @param value - The value to be returned.
@@ -472,7 +477,7 @@ export declare class Failure<T> implements IResult<T> {
     /**
      * {@inheritdoc IResult.report}
      */
-    report(reporter?: IResultReporter<T>, options?: IResultReportOptions): this;
+    report(reporter?: IResultReporter<T>, options?: IResultReportOptions<unknown>): Failure<T>;
     /**
      * Get a 'friendly' string representation of this object.
      * @remarks
@@ -598,7 +603,7 @@ export declare class DetailedSuccess<T, TD> extends Success<T> {
     /**
      * {@inheritdoc IResult.report}
      */
-    report(reporter?: IResultReporter<T, TD>, options?: IResultReportOptions<TD>): this;
+    report(reporter?: IResultReporter<T, unknown>, options?: IResultReportOptions<unknown>): DetailedSuccess<T, TD>;
     /**
      * Creates a {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value and
      * optional detail.
@@ -668,7 +673,7 @@ export declare class DetailedFailure<T, TD> extends Failure<T> {
     /**
      * {@inheritdoc IResult.report}
      */
-    report(reporter?: IResultReporter<T, TD>, options?: IResultReportOptions<TD>): this;
+    report(reporter?: IResultReporter<T, unknown>, options?: IResultReportOptions<unknown>): DetailedFailure<T, TD>;
     orThrow(logOrFormat?: IResultLogger<TD> | ErrorFormatter<TD>): never;
     orThrow(cb: ErrorFormatter): never;
     /**