@decafhub/decaf-client-extras 0.0.1

package/es/reports/valuation/-remote-valuation-report-consolidated.js

@@ -0,0 +1,56 @@
+import { customError, Left, Right } from '@telostat/prelude';
+import { recompileBaseValuationReport } from './-remote-valuation-report-shared';
+/**
+ * Attempts to retrieve remote consolidated valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote consolidated valuation report endpoint query parameters.
+ * @returns Remote (raw) consolidated valuation report data.
+ */
+export function fetchRemoteConsolidatedValuationReport(client, query) {
+    return client.barista
+        .get('/consolidation/', {
+        params: {
+            ccy: query.currency,
+            date: query.date,
+            type: query.dateType,
+            sandbox: query.sandbox,
+            c: query.containerType,
+            i: query.containerElements,
+        },
+    })
+        .then((x) => Right(x.data))
+        .catch((err) => Left(customError('Error while attempting to fetch remote consolidated valuation report', err)));
+}
+/**
+ * Attempts to re-compile the raw, remote consolidated valuation report and
+ * return it.
+ *
+ * @param x Raw, remote consolidated valuation report.
+ * @returns Either of an error message or the re-compiled consolidated valuation
+ * report.
+ */
+export function recompileConsolidatedValuationReport(x) {
+    // Attempt to get the base valuation report:
+    const baseReport = recompileBaseValuationReport(x);
+    // Add consolidated valuation report specific fields and return:
+    return baseReport.map((report) => ({
+        ...report,
+        containerType: x.containers.level,
+        containers: x.containers.containers,
+    }));
+}
+/**
+ * Attempts to retrieve remote consolidated valuation report, compiles it to
+ * [[ConsolidatedValuationReport]] and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote consolidated valuation report endpoint query parameters.
+ * @returns Recompiled consolidated valuation report data.
+ */
+export async function fetchConsolidatedValuationReport(client, query) {
+    // Attempt to fetch the remote, raw report:
+    const rawReport = await fetchRemoteConsolidatedValuationReport(client, query);
+    // Attempt to recompile the report (if any) and return:
+    return rawReport.chain(recompileConsolidatedValuationReport);
+}

package/es/reports/valuation/-remote-valuation-report-portfolio.d.ts

@@ -0,0 +1,150 @@
+import { DecafClient } from '@decafhub/decaf-client';
+import { CustomError, Either, SDate, SDateTime } from '@telostat/prelude';
+import { ActionId, CurrencyCode, DateType, ExternalValuationId, OhlcSeriesId, PortfolioId, PrincipalId, ShareClassFeeScheduleId, ShareClassId } from '../../commons';
+import { RemoteBaseValuationReport } from './-remote-valuation-report-shared';
+import { PortfolioValuationReport, PortfolioValuationReportShareClassValue } from './-valuation-report-portfolio';
+import { ValuationReportPortfolio } from './-valuation-report-shared';
+/**
+ * Remote portfolio valuation report query type.
+ */
+export interface PortfolioValuationReportQuery {
+    /**
+     * Date of valuation report.
+     */
+    date: SDate;
+    /**
+     * Date type of the valuation report.
+     */
+    dateType: DateType;
+    /**
+     * Reference currency of the valuation report.
+     */
+    currency: CurrencyCode;
+    /**
+     * Portfolio the valuation report is requested for.
+     */
+    portfolio: PortfolioId;
+}
+/**
+ * Type definition for the remote (raw) portfolio valuation report data.
+ */
+export interface RemotePortfolioValuationReport extends RemoteBaseValuationReport {
+    portfolio: ValuationReportPortfolio;
+    scvals: RemoteValuationShareClassValue[];
+    subscriptions?: number;
+}
+/**
+ * Type definition for share class valuation on the remote portfolio valuation
+ * report.
+ */
+export interface RemoteValuationShareClassValue {
+    shareclass: RemoteValuationShareClass;
+    external?: RemoteValuationExternalValue;
+    nav: number;
+    nav_adjusted: number;
+    nav_adjusted_total: number;
+    coefficient: number;
+    gav_refccy: number;
+    gav_clsccy: number;
+    sharecount_prev: number;
+    sharecount_curr: number;
+    sharecount_diff: number;
+    px_refccy: number;
+    px_clsccy: number;
+    ytdext?: number;
+    ytdint?: number;
+}
+/**
+ * Type definition for share class on the remote portfolio valuation report.
+ */
+export interface RemoteValuationShareClass {
+    id: ShareClassId;
+    created: SDateTime;
+    creator: PrincipalId;
+    updated: SDateTime;
+    updater: PrincipalId;
+    guid: string;
+    portfolio: PortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin?: string;
+    bbgticker?: string;
+    liquidity?: string;
+    jurisdiction?: string;
+    administrator?: string;
+    mininvestment?: string;
+    subredperiod?: string;
+    freqmngt?: number;
+    freqperf?: number;
+    benchmark?: OhlcSeriesId;
+    description?: string;
+    feeschedules: ShareClassFeeScheduleId[];
+    effectivefeeschedule?: ShareClassFeeScheduleId;
+    subscriptions: ActionId[];
+    outstanding?: number;
+}
+/**
+ * Type definition for external valuation on the remote portfolio valuation
+ * report.
+ */
+export interface RemoteValuationExternalValue {
+    id: ExternalValuationId;
+    created: SDateTime;
+    creator: PrincipalId;
+    updated: SDateTime;
+    updater: PrincipalId;
+    guid: string;
+    portfolio: PortfolioId;
+    shareclass?: ShareClassId;
+    date: SDate;
+    ccy: CurrencyCode;
+    shares?: number;
+    price?: number;
+    nav?: number;
+    aum?: number;
+    hedgepnl?: number;
+    feemngt?: number;
+    feeperf?: number;
+    otheraccrued?: number;
+    totalaccrued?: number;
+    subred?: number;
+    perfdaily?: number;
+    perfweekly?: number;
+    perfmonthly?: number;
+    perfytd?: number;
+    perfstart?: number;
+    coefficient?: number;
+}
+/**
+ * Attempts to retrieve remote portfolio valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote portfolio valuation report endpoint query parameters.
+ * @returns Remote (raw) portfolio valuation report data.
+ */
+export declare function fetchRemotePortfolioValuationReport(client: DecafClient, query: PortfolioValuationReportQuery): Promise<Either<CustomError, RemotePortfolioValuationReport>>;
+/**
+ * Attempts to recompile remote valuation report share class value.
+ *
+ * @param x remote valuation report share class value object.
+ * @return Recompiled valuation report share class value object.
+ */
+export declare function toShareClassValue(x: RemoteValuationShareClassValue): PortfolioValuationReportShareClassValue;
+/**
+ * Attempts to re-compile the raw, remote portfolio valuation report and
+ * return it.
+ *
+ * @param x Raw, remote portfolio valuation report.
+ * @returns Either of an error message or the re-compiled portfolio valuation
+ * report.
+ */
+export declare function recompilePortfolioValuationReport(x: RemotePortfolioValuationReport): Either<CustomError, PortfolioValuationReport>;
+/**
+ * Attempts to retrieve remote portfolio valuation report, compiles it to
+ * [[PortfolioValuationReport]] and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote portolio valuation report endpoint query parameters.
+ * @returns Recompiled portolio valuation report data.
+ */
+export declare function fetchPortfolioValuationReport(client: DecafClient, query: PortfolioValuationReportQuery): Promise<Either<CustomError, PortfolioValuationReport>>;

package/es/reports/valuation/-remote-valuation-report-portfolio.js

@@ -0,0 +1,134 @@
+import { asDecimal, customError, Left, Maybe, maybeDecimal, Right, sanitizedNonEmptyText, zero, } from '@telostat/prelude';
+import { recompileBaseValuationReport } from './-remote-valuation-report-shared';
+/**
+ * Attempts to retrieve remote portfolio valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote portfolio valuation report endpoint query parameters.
+ * @returns Remote (raw) portfolio valuation report data.
+ */
+export function fetchRemotePortfolioValuationReport(client, query) {
+    return client.barista
+        .get('/portfolioreport/', {
+        params: {
+            ccy: query.currency,
+            date: query.date,
+            type: query.dateType,
+            portfolio: `${query.portfolio}`,
+        },
+    })
+        .then((x) => Right(x.data))
+        .catch((err) => Left(customError('Error while attempting to fetch remote portfolio valuation report', err)));
+}
+/**
+ * Attempts to recompile remote valuation report share class value.
+ *
+ * @param x remote valuation report share class value object.
+ * @return Recompiled valuation report share class value object.
+ */
+export function toShareClassValue(x) {
+    return {
+        shareclass: {
+            id: x.shareclass.id,
+            created: x.shareclass.created,
+            creator: Maybe.fromNullable(x.shareclass.creator),
+            updated: x.shareclass.updated,
+            updater: Maybe.fromNullable(x.shareclass.updater),
+            guid: x.shareclass.guid,
+            portfolio: x.shareclass.portfolio,
+            name: x.shareclass.name,
+            currency: x.shareclass.currency,
+            isin: sanitizedNonEmptyText(x.shareclass.isin),
+            bbgticker: sanitizedNonEmptyText(x.shareclass.bbgticker),
+            liquidity: sanitizedNonEmptyText(x.shareclass.liquidity),
+            jurisdiction: sanitizedNonEmptyText(x.shareclass.jurisdiction),
+            administrator: sanitizedNonEmptyText(x.shareclass.administrator),
+            minimumInvestment: sanitizedNonEmptyText(x.shareclass.mininvestment),
+            subscriptionRedemptionPeriod: sanitizedNonEmptyText(x.shareclass.subredperiod),
+            managementFeeFrequency: Maybe.fromNullable(x.shareclass.freqmngt),
+            performanceFeeFrequency: Maybe.fromNullable(x.shareclass.freqperf),
+            benchmark: Maybe.fromNullable(x.shareclass.benchmark),
+            description: sanitizedNonEmptyText(x.shareclass.description),
+            feeScheduleIds: x.shareclass.feeschedules,
+            effectiveFeeScheduleId: Maybe.fromNullable(x.shareclass.effectivefeeschedule),
+            subscriptionIds: x.shareclass.subscriptions,
+            outstanding: maybeDecimal(x.shareclass.outstanding),
+        },
+        external: Maybe.fromNullable(x.external).map((ev) => ({
+            id: ev.id,
+            created: ev.created,
+            creator: Maybe.fromNullable(ev.updater),
+            updated: ev.updated,
+            updater: Maybe.fromNullable(ev.updater),
+            guid: ev.guid,
+            portfolio: ev.portfolio,
+            shareclass: Maybe.fromNullable(ev.shareclass),
+            date: ev.date,
+            ccy: ev.ccy,
+            shares: maybeDecimal(ev.shares),
+            price: maybeDecimal(ev.price),
+            nav: maybeDecimal(ev.nav),
+            aum: maybeDecimal(ev.aum),
+            hedgepnl: maybeDecimal(ev.hedgepnl),
+            feemngt: maybeDecimal(ev.feemngt),
+            feeperf: maybeDecimal(ev.feeperf),
+            otheraccrued: maybeDecimal(ev.otheraccrued),
+            totalaccrued: maybeDecimal(ev.totalaccrued),
+            subred: maybeDecimal(ev.subred),
+            perfdaily: maybeDecimal(ev.perfdaily),
+            perfweekly: maybeDecimal(ev.perfweekly),
+            perfmonthly: maybeDecimal(ev.perfmonthly),
+            perfytd: maybeDecimal(ev.perfytd),
+            perfstart: maybeDecimal(ev.perfstart),
+            coefficient: maybeDecimal(ev.coefficient),
+        })),
+        nav: asDecimal(x.nav),
+        navAdjusted: asDecimal(x.nav_adjusted),
+        navAdjustedTotal: asDecimal(x.nav_adjusted_total),
+        coefficient: asDecimal(x.coefficient),
+        gavRefccy: asDecimal(x.gav_refccy),
+        gavClsccy: asDecimal(x.gav_clsccy),
+        sharecountPrev: asDecimal(x.sharecount_prev),
+        sharecountCurr: asDecimal(x.sharecount_curr),
+        sharecountDiff: asDecimal(x.sharecount_diff),
+        pxRefCcy: asDecimal(x.px_refccy),
+        pxClsCcy: asDecimal(x.px_clsccy),
+        ytdExt: maybeDecimal(x.ytdext),
+        ytdInt: maybeDecimal(x.ytdint),
+    };
+}
+/**
+ * Attempts to re-compile the raw, remote portfolio valuation report and
+ * return it.
+ *
+ * @param x Raw, remote portfolio valuation report.
+ * @returns Either of an error message or the re-compiled portfolio valuation
+ * report.
+ */
+export function recompilePortfolioValuationReport(x) {
+    // Attempt to get the base valuation report:
+    const baseReport = recompileBaseValuationReport(x);
+    // Add consolidated valuation report specific fields and return:
+    return baseReport.map((report) => {
+        return {
+            ...report,
+            portfolio: x.portfolio,
+            subscriptions: maybeDecimal(x.subscriptions).orDefault(zero),
+            shareClassValues: x.scvals.map(toShareClassValue),
+        };
+    });
+}
+/**
+ * Attempts to retrieve remote portfolio valuation report, compiles it to
+ * [[PortfolioValuationReport]] and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote portolio valuation report endpoint query parameters.
+ * @returns Recompiled portolio valuation report data.
+ */
+export async function fetchPortfolioValuationReport(client, query) {
+    // Attempt to fetch the remote, raw report:
+    const rawReport = await fetchRemotePortfolioValuationReport(client, query);
+    // Attempt to recompile the report (if any) and return:
+    return rawReport.chain(recompilePortfolioValuationReport);
+}

package/es/reports/valuation/-remote-valuation-report-shared.d.ts

@@ -0,0 +1,233 @@
+import { CustomError, Decimal, Either, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { ArtifactId, ArtifactTypeId, CurrencyCode, DateType } from '../../commons';
+import { BaseValuationReport, BaseValuationReportHolding, ValuationReportAccount, ValuationReportAccounts, ValuationReportAccrual, ValuationReportArtifact, ValuationReportFigureOrgRef, ValuationReportHolding } from './-valuation-report-shared';
+export interface RemoteBaseValuationReport {
+    reported: SDateTime;
+    asof: SDate;
+    type: DateType;
+    ccy: CurrencyCode;
+    accounts: ValuationReportAccounts;
+    holdings: RemoteValuationReportHolding[];
+    accruals: RemoteValuationReportAccrual[];
+    investment?: number;
+    valuation_net?: number;
+    valuation_abs?: number;
+    accrued?: number;
+    liabilities?: number;
+    gav?: number;
+    nav?: number;
+    aum?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    fxrates: RemoteValuationReportFxRate[];
+}
+export interface RemoteValuationReportFxRate {
+    ccy1: CurrencyCode;
+    ccy2: CurrencyCode;
+    value: number;
+    asof: SDate;
+}
+/**
+ * Valuation holding.
+ */
+export interface RemoteValuationReportHolding {
+    artifact: RemoteValuationReportArtifact;
+    tags: {
+        classification: {
+            name: string;
+            order?: string | number;
+        }[];
+    };
+    quantity: number;
+    accounts: ValuationReportAccount[];
+    investment: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        txncosts: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            org?: number;
+            ref?: number;
+        };
+    };
+    valuation: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+        exposure: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+    };
+    children: RemoteValuationReportChildHolding[];
+    change?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Valuation child holding.
+ */
+export interface RemoteValuationReportChildHolding {
+    artifact: RemoteValuationReportArtifact;
+    tags: {};
+    quantity: number;
+    accounts: ValuationReportAccount[];
+    investment: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        txncosts: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            org?: number;
+            ref?: number;
+        };
+    };
+    valuation: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+        exposure: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+    };
+    change?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Valuation artifact.
+ */
+export interface RemoteValuationReportArtifact {
+    id: ArtifactId;
+    guid: string;
+    type: {
+        id: ArtifactTypeId;
+        name: string;
+        order: number;
+    };
+    stype?: string;
+    symbol: string;
+    name?: string;
+    ccy?: CurrencyCode;
+    quantity: number;
+    country?: string;
+    issuer?: string;
+    sector?: string;
+    mic?: string;
+    ticker?: string;
+    isin?: string;
+    figi?: string;
+    expiry?: SDate;
+    underlying_id?: ArtifactId;
+}
+/**
+ * Valuation accrual.
+ */
+export interface RemoteValuationReportAccrual {
+    name: string;
+    value: number;
+    accounts: RemoteValuationReportAccrualByAccount[];
+}
+/**
+ * Valuation accrual by account.
+ */
+export interface RemoteValuationReportAccrualByAccount {
+    account: ValuationReportAccount;
+    value: number;
+    accruals: RemoteValuationReportAccrualByCurrency[];
+}
+/**
+ * Valuation accrual by account by currency.
+ */
+export interface RemoteValuationReportAccrualByCurrency {
+    artifact: RemoteValuationReportArtifact;
+    ccy: CurrencyCode;
+    value: {
+        org?: number;
+        ref?: number;
+    };
+}
+export declare function toArtifact(x: RemoteValuationReportArtifact): ValuationReportArtifact;
+export declare function toAccrual(x: RemoteValuationReportAccrual): ValuationReportAccrual;
+export declare function toOrgRef(x: {
+    org?: number;
+    ref?: number;
+}): ValuationReportFigureOrgRef;
+export declare function toMaybeOrgRef(x?: {
+    org?: number;
+    ref?: number;
+}): Maybe<ValuationReportFigureOrgRef>;
+export declare function toBaseHolding(nav: Decimal, x: RemoteValuationReportHolding | RemoteValuationReportChildHolding): BaseValuationReportHolding;
+export declare function toHolding(nav: Decimal, x: RemoteValuationReportHolding): ValuationReportHolding;
+/**
+ * Attempts to re-compile the raw, remote base valuation report and
+ * return it.
+ *
+ * @param x Raw, remote base valuation report.
+ * @returns Either of an error message or the re-compiled base valuation
+ * report.
+ */
+export declare function recompileBaseValuationReport(x: RemoteBaseValuationReport): Either<CustomError, BaseValuationReport>;

package/es/reports/valuation/-remote-valuation-report-shared.js

@@ -0,0 +1,127 @@
+import { asDecimal, Just, Maybe, maybeDecimal, Right, safeDiv, sanitizedNonEmptyText, zero, } from '@telostat/prelude';
+export function toArtifact(x) {
+    return {
+        id: x.id,
+        guid: x.guid,
+        type: x.type,
+        stype: sanitizedNonEmptyText(x.stype),
+        symbol: x.symbol,
+        name: sanitizedNonEmptyText(x.name),
+        ccy: Maybe.fromNullable(x.ccy),
+        quantity: asDecimal(x.quantity),
+        country: sanitizedNonEmptyText(x.country),
+        issuer: sanitizedNonEmptyText(x.issuer),
+        sector: sanitizedNonEmptyText(x.sector),
+        mic: sanitizedNonEmptyText(x.mic),
+        ticker: sanitizedNonEmptyText(x.ticker),
+        isin: sanitizedNonEmptyText(x.isin),
+        figi: sanitizedNonEmptyText(x.figi),
+        expiry: Maybe.fromNullable(x.expiry),
+        underlyingId: Maybe.fromNullable(x.underlying_id),
+    };
+}
+export function toAccrual(x) {
+    return {
+        name: x.name,
+        value: asDecimal(x.value),
+        accounts: x.accounts.map((y) => ({
+            account: y.account,
+            value: asDecimal(y.value),
+            accruals: y.accruals.map((z) => ({
+                artifact: toArtifact(z.artifact),
+                ccy: z.ccy,
+                value: { org: asDecimal(z.value.org || 0), ref: asDecimal(z.value.ref || 0) },
+            })),
+        })),
+    };
+}
+export function toOrgRef(x) {
+    return {
+        org: maybeDecimal(x.org).orDefault(zero),
+        ref: maybeDecimal(x.ref).orDefault(zero),
+    };
+}
+export function toMaybeOrgRef(x) {
+    return Maybe.fromNullable(x).chain(({ org, ref }) => maybeDecimal(org).chain((o) => maybeDecimal(ref).chain((r) => Just({ org: o, ref: r }))));
+}
+export function toBaseHolding(nav, x) {
+    return {
+        artifact: toArtifact(x.artifact),
+        quantity: asDecimal(x.quantity),
+        investment: {
+            px: toOrgRef(x.investment.px),
+            txncosts: toMaybeOrgRef(x.investment.txncosts),
+            accrued: toMaybeOrgRef(x.investment.accrued),
+            value: toOrgRef(x.investment.value),
+        },
+        valuation: {
+            px: toOrgRef(x.valuation.px),
+            accrued: toMaybeOrgRef(x.valuation.accrued),
+            value: {
+                net: toOrgRef(x.valuation.value.net),
+                abs: toOrgRef(x.valuation.value.abs),
+            },
+            exposure: {
+                net: toOrgRef(x.valuation.exposure.net),
+                abs: toOrgRef(x.valuation.exposure.abs),
+            },
+        },
+        valuePercentage: safeDiv(maybeDecimal(x.valuation.value.net.ref).orDefault(zero), nav),
+        netExposurePercentage: safeDiv(maybeDecimal(x.valuation.exposure.net.ref).orDefault(zero), nav),
+        absExposurePercentage: safeDiv(maybeDecimal(x.valuation.exposure.abs.ref).orDefault(zero), nav),
+        change: maybeDecimal(x.change),
+        pnl: maybeDecimal(x.pnl).orDefault(zero),
+        pnlToInvestment: maybeDecimal(x.pnl_to_investment),
+        opendate: x.opendate,
+        lastdate: x.lastdate,
+    };
+}
+export function toHolding(nav, x) {
+    return {
+        ...toBaseHolding(nav, x),
+        classification: x.tags.classification.map((n) => ({ ...n, order: n.order || '' })),
+        accounts: x.accounts,
+        children: Maybe.fromNullable(x.children)
+            .filter((mc) => mc.length !== 0)
+            .map((mc) => mc.map((c) => ({
+            ...toBaseHolding(nav, c),
+            account: c.accounts[0],
+        }))),
+    };
+}
+/**
+ * Attempts to re-compile the raw, remote base valuation report and
+ * return it.
+ *
+ * @param x Raw, remote base valuation report.
+ * @returns Either of an error message or the re-compiled base valuation
+ * report.
+ */
+export function recompileBaseValuationReport(x) {
+    const nav = maybeDecimal(x.nav).orDefault(zero);
+    const report = {
+        asof: x.reported,
+        date: x.asof,
+        dateType: x.type,
+        currency: x.ccy,
+        accounts: x.accounts,
+        holdings: x.holdings.map((rh) => toHolding(nav, rh)),
+        accruals: x.accruals.map(toAccrual),
+        fxRates: x.fxrates.map((r) => ({ ccy1: r.ccy1, ccy2: r.ccy2, value: asDecimal(r.value), asof: r.asof })),
+        figures: {
+            investment: maybeDecimal(x.investment).orDefault(zero),
+            valuation: {
+                net: maybeDecimal(x.valuation_net).orDefault(zero),
+                abs: maybeDecimal(x.valuation_abs).orDefault(zero),
+            },
+            accrued: maybeDecimal(x.accrued).orDefault(zero),
+            liabilities: maybeDecimal(x.liabilities).orDefault(zero),
+            gav: maybeDecimal(x.gav).orDefault(zero),
+            nav,
+            aum: maybeDecimal(x.aum).orDefault(zero),
+            pnl: maybeDecimal(x.pnl).orDefault(zero),
+            pnlToInvestment: maybeDecimal(x.pnl_to_investment),
+        },
+    };
+    return Right(report);
+}