@hmcts/opal-frontend-common 0.0.83 → 0.0.85

package/fesm2022/hmcts-opal-frontend-common-guards-business-unit-route-permissions.mjs

@@ -0,0 +1,98 @@
+import { InjectionToken, inject } from '@angular/core';
+import { createUrlTreeFromSnapshot, Router } from '@angular/router';
+import { isObservable, firstValueFrom } from 'rxjs';
+import { PermissionsService } from '@hmcts/opal-frontend-common/services/permissions-service';
+import { PAGES_ROUTING_PATHS } from '@hmcts/opal-frontend-common/pages/routing/constants';
+import { OpalUserService } from '@hmcts/opal-frontend-common/services/opal-user-service';
+
+/**
+ * Injection token used by consuming applications to provide a resolver that can
+ * determine the business unit for the current route context.
+ */
+const BUSINESS_UNIT_ID_RESOLVER = new InjectionToken('BUSINESS_UNIT_ID_RESOLVER');
+/**
+ * Resolves values that may be synchronous, promise-based, or observable-based into a promise.
+ *
+ * @param value - The value to resolve.
+ * @returns A promise containing the resolved value.
+ */
+const resolveMaybeAsync = async (value) => isObservable(value) ? firstValueFrom(value) : Promise.resolve(value);
+/**
+ * Reads and normalizes the permission ids declared on route data.
+ *
+ * @param route - The route whose permission metadata should be inspected.
+ * @returns A filtered array of numeric permission ids.
+ */
+const getRoutePermissionIds = (route) => {
+    const routePermissionIds = route.data?.['routePermissionId'];
+    if (Array.isArray(routePermissionIds)) {
+        return routePermissionIds.filter((permissionId) => typeof permissionId === 'number');
+    }
+    if (typeof routePermissionIds === 'number') {
+        return [routePermissionIds];
+    }
+    return [];
+};
+/**
+ * Creates the access denied redirect for permission failures.
+ *
+ * Absolute paths are resolved from the app root. Relative paths are resolved
+ * from the guarded route's parent so account-flow denied pages stay under the
+ * current account route.
+ *
+ * @param route - The route being protected by the guard.
+ * @param router - The router used to create the redirect URL tree.
+ * @param accessDeniedPath - The configured access denied path.
+ * @returns A URL tree pointing to the denied route.
+ */
+const toAccessDeniedUrlTree = (route, router, accessDeniedPath) => {
+    if (accessDeniedPath.startsWith('/')) {
+        return router.createUrlTree([accessDeniedPath]);
+    }
+    return createUrlTreeFromSnapshot(route.parent ?? route, [accessDeniedPath]);
+};
+/**
+ * Guard that checks route permissions against the business unit resolved for the
+ * current route instead of against the user's global permission set.
+ *
+ * If the route does not declare any permission ids, the guard allows access.
+ * Otherwise it loads the logged-in user state, resolves the route business unit,
+ * and confirms that at least one declared permission exists within that business unit.
+ *
+ * @param route - The route being activated.
+ * @returns `true` when access is allowed, otherwise a redirect to access denied.
+ */
+const businessUnitRoutePermissionsGuard = async (route) => {
+    const routePermissionIds = getRoutePermissionIds(route);
+    if (!routePermissionIds.length) {
+        return true;
+    }
+    const permissionService = inject(PermissionsService);
+    const opalUserService = inject(OpalUserService);
+    const businessUnitResolver = inject(BUSINESS_UNIT_ID_RESOLVER);
+    const router = inject(Router);
+    const accessDeniedPath = route.data?.['accessDeniedPath'] ?? `/${PAGES_ROUTING_PATHS.children.accessDenied}`;
+    try {
+        const userState = await firstValueFrom(opalUserService.getLoggedInUserState());
+        const businessUnitUsers = userState?.business_unit_users ?? [];
+        if (!businessUnitUsers.length) {
+            return toAccessDeniedUrlTree(route, router, `${accessDeniedPath}`);
+        }
+        const businessUnitId = await resolveMaybeAsync(businessUnitResolver.resolveBusinessUnitId(route));
+        if (typeof businessUnitId !== 'number' || !Number.isFinite(businessUnitId) || businessUnitId <= 0) {
+            return toAccessDeniedUrlTree(route, router, `${accessDeniedPath}`);
+        }
+        const hasAccess = routePermissionIds.some((permissionId) => permissionService.hasBusinessUnitPermissionAccess(permissionId, businessUnitId, businessUnitUsers));
+        return hasAccess ? true : toAccessDeniedUrlTree(route, router, `${accessDeniedPath}`);
+    }
+    catch {
+        return toAccessDeniedUrlTree(route, router, `${accessDeniedPath}`);
+    }
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BUSINESS_UNIT_ID_RESOLVER, businessUnitRoutePermissionsGuard };
+//# sourceMappingURL=hmcts-opal-frontend-common-guards-business-unit-route-permissions.mjs.map

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.83",
+  "version": "0.0.85",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -596,6 +596,11 @@
       "types": "./types/hmcts-opal-frontend-common-guards-account.d.ts",
       "default": "./fesm2022/hmcts-opal-frontend-common-guards-account.mjs"
     },
+    "./guards/business-unit-route-permissions": {
+      "import": "./fesm2022/hmcts-opal-frontend-common-guards-business-unit-route-permissions.mjs",
+      "types": "./types/hmcts-opal-frontend-common-guards-business-unit-route-permissions.d.ts",
+      "default": "./fesm2022/hmcts-opal-frontend-common-guards-business-unit-route-permissions.mjs"
+    },
     "./guards/can-deactivate": {
       "import": "./fesm2022/hmcts-opal-frontend-common-guards-can-deactivate.mjs",
       "types": "./types/hmcts-opal-frontend-common-guards-can-deactivate.d.ts",
@@ -729,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/types/hmcts-opal-frontend-common-guards-business-unit-route-permissions.d.ts

@@ -0,0 +1,38 @@
+import { InjectionToken } from '@angular/core';
+import { ActivatedRouteSnapshot, MaybeAsync, CanActivateFn } from '@angular/router';
+
+/**
+ * Contract implemented by consuming apps to resolve the business unit for the active route.
+ */
+interface BusinessUnitIdResolver {
+    /**
+     * Resolves the business unit id that should be used for route-level permission checks.
+     *
+     * Return `null` when the business unit cannot be determined for the route.
+     *
+     * @param route - The route being protected by the business-unit permission guard.
+     * @returns The business unit id, or `null` when no valid business unit is available.
+     */
+    resolveBusinessUnitId(route: ActivatedRouteSnapshot): MaybeAsync<number | null>;
+}
+
+/**
+ * Injection token used by consuming applications to provide a resolver that can
+ * determine the business unit for the current route context.
+ */
+declare const BUSINESS_UNIT_ID_RESOLVER: InjectionToken<BusinessUnitIdResolver>;
+/**
+ * Guard that checks route permissions against the business unit resolved for the
+ * current route instead of against the user's global permission set.
+ *
+ * If the route does not declare any permission ids, the guard allows access.
+ * Otherwise it loads the logged-in user state, resolves the route business unit,
+ * and confirms that at least one declared permission exists within that business unit.
+ *
+ * @param route - The route being activated.
+ * @returns `true` when access is allowed, otherwise a redirect to access denied.
+ */
+declare const businessUnitRoutePermissionsGuard: CanActivateFn;
+
+export { BUSINESS_UNIT_ID_RESOLVER, businessUnitRoutePermissionsGuard };
+export type { BusinessUnitIdResolver };

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 };