@hmcts/opal-frontend-common 0.0.84 → 0.0.86

package/README.md

@@ -129,8 +129,20 @@ Once any changes have been approved and merged into the main branch, you'll need
 
 1. Increment the version number in both the library's root `package.json` and in `/projects/opal-frontend-common/package.json`.
 2. Commit and push those changes to the main branch.
-3. On GitHub, create a new [release](https://github.com/hmcts/opal-frontend-common-ui-lib/releases) and use the updated version number as a tag.
-4. When the release workflow completes, the library will be published.
+3. Create and push the version tag from the updated main branch:
+
+   ```bash
+   git checkout main
+   git pull
+   git tag vX.Y.Z
+   git push origin vX.Y.Z
+   ```
+
+4. On GitHub, draft a new [release](https://github.com/hmcts/opal-frontend-common-ui-lib/releases) and select the existing `vX.Y.Z` tag from the tag dropdown.
+5. Do not create the tag in the GitHub release form. The tag must already exist so the npm trusted publishing provenance includes the `refs/tags/vX.Y.Z` source repository ref.
+6. When the release workflow completes, the library will be published.
+
+If a publish fails before npm accepts the package version, delete the failed GitHub release and remote tag, then push the existing local tag again before recreating the release from that existing tag. Do not rerun a failed release workflow if the provenance was generated without a tag ref.
 
 After this new version of the library is published, any consuming application should remove the local or outdated version of the library and then install the published version by running:
 

package/fesm2022/hmcts-opal-frontend-common-services-history-transformation-service.mjs

@@ -0,0 +1,329 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+import { DateService } from '@hmcts/opal-frontend-common/services/date-service';
+
+const HISTORY_DETAILS_PATTERNS = {
+    keyNormalise: /[\s_-]/g,
+    snakeCaseBoundary: /([a-z])([A-Z])/g,
+    snakeCaseSeparator: /[\s-]/g,
+    transactionTypeSpace: /\s+/g,
+};
+
+const HISTORY_DETAILS_DATE_SERVICE = new DateService();
+/**
+ * Transforms a raw history item into the configured structured details model.
+ *
+ * @param item - The raw history item.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The transformed details model.
+ */
+function transformHistoryDetails(item, config) {
+    const itemType = normaliseHistoryKey(getHistoryString(item, config.historyItemTypeAliases, config.aliasPathPrefixes, config.emptyValues));
+    const transformer = itemType ? config.transformers[itemType] : null;
+    return transformer ? transformer(item) : transformHistoryFallbackDetails(item, config);
+}
+/**
+ * Transforms raw history items while preserving the rest of each item.
+ *
+ * @param items - The raw history items.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The items with transformed structured details.
+ */
+function transformHistoryItems(items, config) {
+    return items.map((item) => ({
+        ...item,
+        details: transformHistoryDetails(item, config),
+    }));
+}
+/**
+ * Builds fallback details from configured fallback fields when no transformer matches.
+ *
+ * @param item - The raw history item.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The fallback structured details model.
+ */
+function transformHistoryFallbackDetails(item, config) {
+    return createHistoryDetails([
+        createHistoryTextPart(getHistoryString(item, config.fallbackAliases, config.aliasPathPrefixes, config.emptyValues) ??
+            getHistoryString(item, config.historyItemTypeAliases, config.aliasPathPrefixes, config.emptyValues)),
+    ]);
+}
+/**
+ * Creates a details object and normalises an empty secondary line to null.
+ *
+ * @param line1Parts - The primary line parts.
+ * @param line2Parts - The secondary line parts.
+ * @returns The structured details object.
+ */
+function createHistoryDetails(line1Parts, line2Parts = []) {
+    const line1 = line1Parts.filter(isPresentPart);
+    const line2 = line2Parts.filter(isPresentPart);
+    return {
+        line1,
+        line2: line2.length ? line2 : null,
+    };
+}
+/**
+ * Creates a details part after removing empty fragments.
+ *
+ * @param fragments - The fragments for the part.
+ * @returns The details part or null when no fragments are visible.
+ */
+function createHistoryDetailsPart(fragments) {
+    const visibleFragments = fragments.filter(({ text }) => text.length > 0);
+    return visibleFragments.length ? { fragments: visibleFragments } : null;
+}
+/**
+ * Creates a text-only details part.
+ *
+ * @param text - The part text.
+ * @returns The details part or null when text is empty.
+ */
+function createHistoryTextPart(text) {
+    return text ? createHistoryDetailsPart([createHistoryFragment(text)]) : null;
+}
+/**
+ * Creates a details part containing a bold label and plain value.
+ *
+ * @param label - The label text.
+ * @param value - The value text.
+ * @returns The labelled details part or null when value is empty.
+ */
+function createHistoryLabelValuePart(label, value) {
+    return value
+        ? createHistoryDetailsPart([createHistoryFragment(label, { bold: true }), createHistoryFragment(value)])
+        : null;
+}
+/**
+ * Creates a text fragment with default styling flags.
+ *
+ * @param text - The fragment text.
+ * @param options - Optional fragment styling and link metadata.
+ * @returns The details fragment.
+ */
+function createHistoryFragment(text, options = {}) {
+    return {
+        text,
+        bold: options.bold ?? false,
+        hyphen: options.hyphen ?? false,
+        ...(options.link ? { link: options.link } : {}),
+    };
+}
+/**
+ * Creates link metadata for a details fragment.
+ *
+ * @param type - The link type emitted by the UI.
+ * @param emit - The emitted linked entity identifier.
+ * @returns The fragment link metadata.
+ */
+function createHistoryLink(type, emit) {
+    return { type, emit };
+}
+/**
+ * Reads the first non-empty scalar value from candidate aliases as a string.
+ *
+ * @param item - The raw history item.
+ * @param aliases - The candidate field aliases.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The string value or null.
+ */
+function getHistoryString(item, aliases, aliasPathPrefixes, emptyValues) {
+    const value = getHistoryValue(item, aliases, aliasPathPrefixes, emptyValues);
+    if (isHistoryEmptyValue(value, emptyValues) || isHistoryRecord(value)) {
+        return null;
+    }
+    return String(value);
+}
+/**
+ * Reads the first non-empty value from candidate aliases.
+ *
+ * @param item - The raw history item.
+ * @param aliases - The candidate field aliases.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The matched value or null.
+ */
+function getHistoryValue(item, aliases, aliasPathPrefixes, emptyValues) {
+    for (const alias of aliases) {
+        for (const path of getHistoryAliasPaths(alias, aliasPathPrefixes)) {
+            const value = getHistoryValueByPath(item, path);
+            if (!isHistoryEmptyValue(value, emptyValues)) {
+                return value;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Expands an alias into candidate dot-notated paths.
+ *
+ * @param alias - The field alias.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @returns The candidate paths.
+ */
+function getHistoryAliasPaths(alias, aliasPathPrefixes) {
+    return alias.includes('.') ? [alias] : aliasPathPrefixes.map((prefix) => `${prefix}${alias}`);
+}
+/**
+ * Reads a value from an history item using a dot-notated path.
+ *
+ * @param item - The raw history item.
+ * @param path - The dot-notated path.
+ * @returns The matched value or undefined.
+ */
+function getHistoryValueByPath(item, path) {
+    return path.split('.').reduce((value, key) => {
+        if (!isHistoryRecord(value)) {
+            return undefined;
+        }
+        return value[key];
+    }, item);
+}
+/**
+ * Checks whether a value is a non-null record.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a record.
+ */
+function isHistoryRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Checks whether a value should be treated as empty.
+ *
+ * @param value - The value to check.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns True when the value is empty.
+ */
+function isHistoryEmptyValue(value, emptyValues) {
+    return emptyValues.includes(value);
+}
+/**
+ * Checks whether a string value is present.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a non-empty string.
+ */
+function isHistoryPresentString(value) {
+    return !!value;
+}
+/**
+ * Normalises a history item type key for transformer lookup.
+ *
+ * @param value - The raw key.
+ * @returns The normalised key or null.
+ */
+function normaliseHistoryKey(value) {
+    return value ? value.replace(HISTORY_DETAILS_PATTERNS.keyNormalise, '').toLowerCase() : null;
+}
+/**
+ * Normalises a transaction type code for switch matching.
+ *
+ * @param value - The raw transaction type.
+ * @returns The normalised transaction type or null.
+ */
+function normaliseHistoryTransactionType(value) {
+    return value ? value.trim().toUpperCase().replace(HISTORY_DETAILS_PATTERNS.transactionTypeSpace, ' ') : null;
+}
+/**
+ * Converts a camel, space, or hyphen value to snake case.
+ *
+ * @param value - The raw value.
+ * @returns The snake case value.
+ */
+function toHistorySnakeCase(value) {
+    return value
+        .replace(HISTORY_DETAILS_PATTERNS.snakeCaseBoundary, '$1_$2')
+        .replace(HISTORY_DETAILS_PATTERNS.snakeCaseSeparator, '_')
+        .toLowerCase();
+}
+/**
+ * Formats configured date strings to the configured output format.
+ *
+ * @param value - The raw date value.
+ * @param dateFormat - The input and output date formats.
+ * @returns The formatted date or original value when parsing fails.
+ */
+function formatHistoryDate(value, dateFormat) {
+    if (!value) {
+        return null;
+    }
+    const parsedFormattedDate = HISTORY_DETAILS_DATE_SERVICE.getFromFormat(value, dateFormat.input);
+    if (HISTORY_DETAILS_DATE_SERVICE.isValidDate(parsedFormattedDate)) {
+        return HISTORY_DETAILS_DATE_SERVICE.getFromFormatToFormat(value, dateFormat.input, dateFormat.output);
+    }
+    const isoDate = HISTORY_DETAILS_DATE_SERVICE.getFromIso(value);
+    return HISTORY_DETAILS_DATE_SERVICE.isValidDate(isoDate)
+        ? HISTORY_DETAILS_DATE_SERVICE.toFormat(isoDate, dateFormat.output)
+        : value;
+}
+/**
+ * Formats numeric values as currency while preserving preformatted text.
+ *
+ * @param value - The raw money value.
+ * @param currencyPrefix - The currency prefix to prepend to numeric values.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The formatted money text or null.
+ */
+function formatHistoryMoney(value, currencyPrefix, emptyValues) {
+    if (isHistoryEmptyValue(value, emptyValues)) {
+        return null;
+    }
+    if (typeof value === 'number') {
+        return `${currencyPrefix}${value.toFixed(2)}`;
+    }
+    const text = String(value);
+    if (text.startsWith(currencyPrefix)) {
+        return text;
+    }
+    const numericValue = Number(text);
+    return Number.isFinite(numericValue) ? `${currencyPrefix}${numericValue.toFixed(2)}` : text;
+}
+/**
+ * Checks whether a details part should be kept in the rendered output.
+ *
+ * @param value - The details part to check.
+ * @returns True when the part is present.
+ */
+function isPresentPart(value) {
+    return !!value;
+}
+
+class HistoryTransformationService {
+    /**
+     * Transforms a raw history item into the structured details model.
+     *
+     * @param item - The raw history item.
+     * @param config - The domain-specific transformation configuration.
+     * @returns The transformed history details.
+     */
+    transformDetails(item, config) {
+        return transformHistoryDetails(item, config);
+    }
+    /**
+     * Transforms raw history items while preserving the rest of each item.
+     *
+     * @param items - The raw history items.
+     * @param config - The domain-specific transformation configuration.
+     * @returns The items with transformed structured details.
+     */
+    transformItems(items, config) {
+        return transformHistoryItems(items, config);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: HistoryTransformationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: HistoryTransformationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: HistoryTransformationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { HISTORY_DETAILS_PATTERNS, HistoryTransformationService, createHistoryDetails, createHistoryDetailsPart, createHistoryFragment, createHistoryLabelValuePart, createHistoryLink, createHistoryTextPart, formatHistoryDate, formatHistoryMoney, getHistoryAliasPaths, getHistoryString, getHistoryValue, getHistoryValueByPath, isHistoryEmptyValue, isHistoryPresentString, isHistoryRecord, normaliseHistoryKey, normaliseHistoryTransactionType, toHistorySnakeCase, transformHistoryDetails, transformHistoryFallbackDetails, transformHistoryItems };
+//# sourceMappingURL=hmcts-opal-frontend-common-services-history-transformation-service.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmcts/opal-frontend-common",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -734,6 +734,11 @@
       "types": "./types/hmcts-opal-frontend-common-services-app-initializer-service.d.ts",
       "default": "./fesm2022/hmcts-opal-frontend-common-services-app-initializer-service.mjs"
     },
+    "./services/history-transformation-service": {
+      "import": "./fesm2022/hmcts-opal-frontend-common-services-history-transformation-service.mjs",
+      "types": "./types/hmcts-opal-frontend-common-services-history-transformation-service.d.ts",
+      "default": "./fesm2022/hmcts-opal-frontend-common-services-history-transformation-service.mjs"
+    },
     "./services/transfer-state-service": {
       "import": "./fesm2022/hmcts-opal-frontend-common-services-transfer-state-service.mjs",
       "types": "./types/hmcts-opal-frontend-common-services-transfer-state-service.d.ts",

package/styles/styles.scss

@@ -5,6 +5,7 @@
    ==========================================================================
    These imports include external styles used across the application.
 */
+@use '@ministryofjustice/frontend/moj/base' as mojBase;
 @use 'govuk-frontend/dist/govuk/index' as *;
 @use '@ministryofjustice/frontend/moj/all' as moj;
 @use './custom/_custom-section_break.scss';

package/types/hmcts-opal-frontend-common-services-date-service.d.ts

@@ -85,7 +85,7 @@ declare class DateService {
      * @param value - The string value in ISO format.
      * @returns A DateTime object representing the given value.
      */
-    getFromIso(value: string): DateTime;
+    getFromIso(value: string): DateTime<true> | DateTime<false>;
     /**
      * Returns the current date and time.
      * @returns {DateTime} The current date and time.

package/types/hmcts-opal-frontend-common-services-history-transformation-service.d.ts

@@ -0,0 +1,250 @@
+import * as i0 from '@angular/core';
+
+interface IHistoryDetailsLink {
+    type: string;
+    emit: string;
+}
+
+interface IHistoryDetailsFragment {
+    text: string;
+    bold: boolean;
+    hyphen: boolean;
+    link?: IHistoryDetailsLink | null;
+}
+
+interface IHistoryDetailsPart {
+    fragments: IHistoryDetailsFragment[];
+}
+
+interface IHistoryDetails {
+    line1: IHistoryDetailsPart[];
+    line2: IHistoryDetailsPart[] | null;
+}
+
+interface IHistoryDetailsDateFormat {
+    input: string;
+    output: string;
+}
+
+type THistoryDetailsRawItem = Record<string, unknown>;
+
+type THistoryDetailsTransformer = (item: THistoryDetailsRawItem) => IHistoryDetails;
+
+type THistoryDetailsTransformerConfig = Record<string, THistoryDetailsTransformer>;
+
+interface IHistoryTransformationConfig {
+    aliasPathPrefixes: string[];
+    dateFormat: IHistoryDetailsDateFormat;
+    emptyValues: readonly unknown[];
+    fallbackAliases: string[];
+    historyItemTypeAliases: string[];
+    transformers: THistoryDetailsTransformerConfig;
+}
+
+declare class HistoryTransformationService {
+    /**
+     * Transforms a raw history item into the structured details model.
+     *
+     * @param item - The raw history item.
+     * @param config - The domain-specific transformation configuration.
+     * @returns The transformed history details.
+     */
+    transformDetails(item: THistoryDetailsRawItem, config: IHistoryTransformationConfig): IHistoryDetails;
+    /**
+     * Transforms raw history items while preserving the rest of each item.
+     *
+     * @param items - The raw history items.
+     * @param config - The domain-specific transformation configuration.
+     * @returns The items with transformed structured details.
+     */
+    transformItems<T extends THistoryDetailsRawItem>(items: T[], config: IHistoryTransformationConfig): Array<Omit<T, 'details'> & {
+        details: IHistoryDetails;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoryTransformationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoryTransformationService>;
+}
+
+declare const HISTORY_DETAILS_PATTERNS: {
+    keyNormalise: RegExp;
+    snakeCaseBoundary: RegExp;
+    snakeCaseSeparator: RegExp;
+    transactionTypeSpace: RegExp;
+};
+
+interface IHistoryFragmentOptions {
+    bold?: boolean;
+    hyphen?: boolean;
+    link?: IHistoryDetailsLink | null;
+}
+
+/**
+ * Transforms a raw history item into the configured structured details model.
+ *
+ * @param item - The raw history item.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The transformed details model.
+ */
+declare function transformHistoryDetails(item: THistoryDetailsRawItem, config: IHistoryTransformationConfig): IHistoryDetails;
+/**
+ * Transforms raw history items while preserving the rest of each item.
+ *
+ * @param items - The raw history items.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The items with transformed structured details.
+ */
+declare function transformHistoryItems<T extends THistoryDetailsRawItem>(items: T[], config: IHistoryTransformationConfig): Array<Omit<T, 'details'> & {
+    details: IHistoryDetails;
+}>;
+/**
+ * Builds fallback details from configured fallback fields when no transformer matches.
+ *
+ * @param item - The raw history item.
+ * @param config - The domain-specific transformation configuration.
+ * @returns The fallback structured details model.
+ */
+declare function transformHistoryFallbackDetails(item: THistoryDetailsRawItem, config: IHistoryTransformationConfig): IHistoryDetails;
+/**
+ * Creates a details object and normalises an empty secondary line to null.
+ *
+ * @param line1Parts - The primary line parts.
+ * @param line2Parts - The secondary line parts.
+ * @returns The structured details object.
+ */
+declare function createHistoryDetails(line1Parts: Array<IHistoryDetailsPart | null>, line2Parts?: Array<IHistoryDetailsPart | null>): IHistoryDetails;
+/**
+ * Creates a details part after removing empty fragments.
+ *
+ * @param fragments - The fragments for the part.
+ * @returns The details part or null when no fragments are visible.
+ */
+declare function createHistoryDetailsPart(fragments: IHistoryDetailsFragment[]): IHistoryDetailsPart | null;
+/**
+ * Creates a text-only details part.
+ *
+ * @param text - The part text.
+ * @returns The details part or null when text is empty.
+ */
+declare function createHistoryTextPart(text: string | null): IHistoryDetailsPart | null;
+/**
+ * Creates a details part containing a bold label and plain value.
+ *
+ * @param label - The label text.
+ * @param value - The value text.
+ * @returns The labelled details part or null when value is empty.
+ */
+declare function createHistoryLabelValuePart(label: string, value: string | null): IHistoryDetailsPart | null;
+/**
+ * Creates a text fragment with default styling flags.
+ *
+ * @param text - The fragment text.
+ * @param options - Optional fragment styling and link metadata.
+ * @returns The details fragment.
+ */
+declare function createHistoryFragment(text: string, options?: IHistoryFragmentOptions): IHistoryDetailsFragment;
+/**
+ * Creates link metadata for a details fragment.
+ *
+ * @param type - The link type emitted by the UI.
+ * @param emit - The emitted linked entity identifier.
+ * @returns The fragment link metadata.
+ */
+declare function createHistoryLink(type: string, emit: string): IHistoryDetailsLink;
+/**
+ * Reads the first non-empty scalar value from candidate aliases as a string.
+ *
+ * @param item - The raw history item.
+ * @param aliases - The candidate field aliases.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The string value or null.
+ */
+declare function getHistoryString(item: THistoryDetailsRawItem, aliases: string[], aliasPathPrefixes: string[], emptyValues: readonly unknown[]): string | null;
+/**
+ * Reads the first non-empty value from candidate aliases.
+ *
+ * @param item - The raw history item.
+ * @param aliases - The candidate field aliases.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The matched value or null.
+ */
+declare function getHistoryValue(item: THistoryDetailsRawItem, aliases: string[], aliasPathPrefixes: string[], emptyValues: readonly unknown[]): unknown;
+/**
+ * Expands an alias into candidate dot-notated paths.
+ *
+ * @param alias - The field alias.
+ * @param aliasPathPrefixes - The prefixes used for unqualified aliases.
+ * @returns The candidate paths.
+ */
+declare function getHistoryAliasPaths(alias: string, aliasPathPrefixes: string[]): string[];
+/**
+ * Reads a value from an history item using a dot-notated path.
+ *
+ * @param item - The raw history item.
+ * @param path - The dot-notated path.
+ * @returns The matched value or undefined.
+ */
+declare function getHistoryValueByPath(item: THistoryDetailsRawItem, path: string): unknown;
+/**
+ * Checks whether a value is a non-null record.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a record.
+ */
+declare function isHistoryRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks whether a value should be treated as empty.
+ *
+ * @param value - The value to check.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns True when the value is empty.
+ */
+declare function isHistoryEmptyValue(value: unknown, emptyValues: readonly unknown[]): boolean;
+/**
+ * Checks whether a string value is present.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a non-empty string.
+ */
+declare function isHistoryPresentString(value: string | null): value is string;
+/**
+ * Normalises a history item type key for transformer lookup.
+ *
+ * @param value - The raw key.
+ * @returns The normalised key or null.
+ */
+declare function normaliseHistoryKey(value: string | null): string | null;
+/**
+ * Normalises a transaction type code for switch matching.
+ *
+ * @param value - The raw transaction type.
+ * @returns The normalised transaction type or null.
+ */
+declare function normaliseHistoryTransactionType(value: string | null): string | null;
+/**
+ * Converts a camel, space, or hyphen value to snake case.
+ *
+ * @param value - The raw value.
+ * @returns The snake case value.
+ */
+declare function toHistorySnakeCase(value: string): string;
+/**
+ * Formats configured date strings to the configured output format.
+ *
+ * @param value - The raw date value.
+ * @param dateFormat - The input and output date formats.
+ * @returns The formatted date or original value when parsing fails.
+ */
+declare function formatHistoryDate(value: string | null, dateFormat: IHistoryDetailsDateFormat): string | null;
+/**
+ * Formats numeric values as currency while preserving preformatted text.
+ *
+ * @param value - The raw money value.
+ * @param currencyPrefix - The currency prefix to prepend to numeric values.
+ * @param emptyValues - Values that should be treated as empty.
+ * @returns The formatted money text or null.
+ */
+declare function formatHistoryMoney(value: unknown, currencyPrefix: string, emptyValues: readonly unknown[]): string | null;
+
+export { HISTORY_DETAILS_PATTERNS, HistoryTransformationService, createHistoryDetails, createHistoryDetailsPart, createHistoryFragment, createHistoryLabelValuePart, createHistoryLink, createHistoryTextPart, formatHistoryDate, formatHistoryMoney, getHistoryAliasPaths, getHistoryString, getHistoryValue, getHistoryValueByPath, isHistoryEmptyValue, isHistoryPresentString, isHistoryRecord, normaliseHistoryKey, normaliseHistoryTransactionType, toHistorySnakeCase, transformHistoryDetails, transformHistoryFallbackDetails, transformHistoryItems };
+export type { IHistoryDetails, IHistoryDetailsDateFormat, IHistoryDetailsFragment, IHistoryDetailsLink, IHistoryDetailsPart, IHistoryFragmentOptions, IHistoryTransformationConfig, THistoryDetailsRawItem, THistoryDetailsTransformer, THistoryDetailsTransformerConfig };