@decafhub/decaf-client-extras 0.4.0 → 0.5.1

package/reports/valuation/-remote-valuation-report-account.d.ts

@@ -0,0 +1,150 @@
+import { DecafClient } from '@decafhub/decaf-client';
+import { CustomError, Either, SDate, SDateTime } from '@telostat/prelude';
+import { CurrencyCode, DateType, DecafAccountId, DecafActionId, DecafExternalValuationId, DecafOhlcSeriesId, DecafPortfolioId, DecafPrincipalId, DecafShareClassFeeScheduleId, DecafShareClassId } from '../../commons';
+import { RemoteBaseValuationReport } from './-remote-valuation-report-shared';
+import { ValuationReportAccount } from './-valuation-report-shared';
+import { AccountValuationReport, AccountValuationReportShareClassValue } from './-valuation-report-account';
+/**
+ * Remote account valuation report query type.
+ */
+export interface AccountValuationReportQuery {
+    /**
+     * Date of valuation report.
+     */
+    date: SDate;
+    /**
+     * Date type of the valuation report.
+     */
+    dateType: DateType;
+    /**
+     * Reference currency of the valuation report.
+     */
+    currency: CurrencyCode;
+    /**
+     * Account the valuation report is requested for.
+     */
+    account: DecafAccountId;
+}
+/**
+ * Type definition for the remote (raw) account valuation report data.
+ */
+export interface RemoteAccountValuationReport extends RemoteBaseValuationReport {
+    account: ValuationReportAccount;
+    scvals: RemoteValuationShareClassValue[];
+    subscriptions?: number;
+}
+/**
+ * Type definition for share class valuation on the remote account 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 account valuation report.
+ */
+export interface RemoteValuationShareClass {
+    id: DecafShareClassId;
+    created: SDateTime;
+    creator: DecafPrincipalId;
+    updated: SDateTime;
+    updater: DecafPrincipalId;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin?: string;
+    bbgticker?: string;
+    liquidity?: string;
+    jurisdiction?: string;
+    administrator?: string;
+    mininvestment?: number;
+    subredperiod?: string;
+    freqmngt?: number;
+    freqperf?: number;
+    benchmark?: DecafOhlcSeriesId;
+    description?: string;
+    feeschedules: DecafShareClassFeeScheduleId[];
+    effectivefeeschedule?: DecafShareClassFeeScheduleId;
+    subscriptions: DecafActionId[];
+    outstanding?: number;
+}
+/**
+ * Type definition for external valuation on the remote account valuation
+ * report.
+ */
+export interface RemoteValuationExternalValue {
+    id: DecafExternalValuationId;
+    created: SDateTime;
+    creator: DecafPrincipalId;
+    updated: SDateTime;
+    updater: DecafPrincipalId;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    shareclass?: DecafShareClassId;
+    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 account valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Remote (raw) account valuation report data.
+ */
+export declare function fetchRemoteAccountValuationReport(client: DecafClient, query: AccountValuationReportQuery): Promise<Either<CustomError, RemoteAccountValuationReport>>;
+/**
+ * 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(s: RemoteValuationShareClassValue): AccountValuationReportShareClassValue;
+/**
+ * Attempts to re-compile the raw, remote account valuation report and
+ * return it.
+ *
+ * @param x Raw, remote account valuation report.
+ * @returns Either of an error message or the re-compiled account valuation
+ * report.
+ */
+export declare function recompileAccountValuationReport(x: RemoteAccountValuationReport): Either<CustomError, AccountValuationReport>;
+/**
+ * Attempts to retrieve remote account valuation report, compiles it to
+ * {@link AccountValuationReport} and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Recompiled account valuation report data.
+ */
+export declare function fetchAccountValuationReport(client: DecafClient, query: AccountValuationReportQuery): Promise<Either<CustomError, AccountValuationReport>>;

package/reports/valuation/-remote-valuation-report-account.js

@@ -0,0 +1,196 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAccountValuationReport = exports.recompileAccountValuationReport = exports.toShareClassValue = exports.fetchRemoteAccountValuationReport = void 0;
+var prelude_1 = require("@telostat/prelude");
+var _remote_valuation_report_shared_1 = require("./-remote-valuation-report-shared");
+/**
+ * Attempts to retrieve remote account valuation report.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Remote (raw) account valuation report data.
+ */
+function fetchRemoteAccountValuationReport(client, query) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, client.barista
+                    .get('/reports/valuation/account/', {
+                    params: {
+                        ccy: query.currency,
+                        date: query.date,
+                        type: query.dateType,
+                        account: "".concat(query.account),
+                    },
+                })
+                    .then(function (x) { return (0, prelude_1.Right)(x.data); })
+                    .catch(function (err) { return (0, prelude_1.Left)((0, prelude_1.customError)('Error while attempting to fetch remote account valuation report', err)); })];
+        });
+    });
+}
+exports.fetchRemoteAccountValuationReport = fetchRemoteAccountValuationReport;
+/**
+ * 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.
+ */
+function toShareClassValue(s) {
+    var shareclass = prelude_1.Maybe.fromNullable(s.shareclass).map(function (x) { return ({
+        id: x.id,
+        created: x.created,
+        creator: prelude_1.Maybe.fromNullable(x.creator),
+        updated: x.updated,
+        updater: prelude_1.Maybe.fromNullable(x.updater),
+        guid: x.guid,
+        portfolio: x.portfolio,
+        name: x.name,
+        currency: x.currency,
+        isin: (0, prelude_1.sanitizedNonEmptyText)(x.isin),
+        bbgticker: (0, prelude_1.sanitizedNonEmptyText)(x.bbgticker),
+        liquidity: (0, prelude_1.sanitizedNonEmptyText)(x.liquidity),
+        jurisdiction: (0, prelude_1.sanitizedNonEmptyText)(x.jurisdiction),
+        administrator: (0, prelude_1.sanitizedNonEmptyText)(x.administrator),
+        minimumInvestment: prelude_1.Maybe.fromNullable(x.mininvestment),
+        subscriptionRedemptionPeriod: (0, prelude_1.sanitizedNonEmptyText)(x.subredperiod),
+        managementFeeFrequency: prelude_1.Maybe.fromNullable(x.freqmngt),
+        performanceFeeFrequency: prelude_1.Maybe.fromNullable(x.freqperf),
+        benchmark: prelude_1.Maybe.fromNullable(x.benchmark),
+        description: (0, prelude_1.sanitizedNonEmptyText)(x.description),
+        feeScheduleIds: x.feeschedules,
+        effectiveFeeScheduleId: prelude_1.Maybe.fromNullable(x.effectivefeeschedule),
+        subscriptionIds: x.subscriptions,
+        outstanding: (0, prelude_1.decimalFromNullable)(x.outstanding),
+    }); });
+    return {
+        shareclass: shareclass,
+        external: prelude_1.Maybe.fromNullable(s.external).map(function (ev) { return ({
+            id: ev.id,
+            created: ev.created,
+            creator: prelude_1.Maybe.fromNullable(ev.updater),
+            updated: ev.updated,
+            updater: prelude_1.Maybe.fromNullable(ev.updater),
+            guid: ev.guid,
+            portfolio: ev.portfolio,
+            shareclass: prelude_1.Maybe.fromNullable(ev.shareclass),
+            date: ev.date,
+            ccy: ev.ccy,
+            shares: (0, prelude_1.decimalFromNullable)(ev.shares),
+            price: (0, prelude_1.decimalFromNullable)(ev.price),
+            nav: (0, prelude_1.decimalFromNullable)(ev.nav),
+            aum: (0, prelude_1.decimalFromNullable)(ev.aum),
+            hedgepnl: (0, prelude_1.decimalFromNullable)(ev.hedgepnl),
+            feemngt: (0, prelude_1.decimalFromNullable)(ev.feemngt),
+            feeperf: (0, prelude_1.decimalFromNullable)(ev.feeperf),
+            otheraccrued: (0, prelude_1.decimalFromNullable)(ev.otheraccrued),
+            totalaccrued: (0, prelude_1.decimalFromNullable)(ev.totalaccrued),
+            subred: (0, prelude_1.decimalFromNullable)(ev.subred),
+            perfdaily: (0, prelude_1.decimalFromNullable)(ev.perfdaily),
+            perfweekly: (0, prelude_1.decimalFromNullable)(ev.perfweekly),
+            perfmonthly: (0, prelude_1.decimalFromNullable)(ev.perfmonthly),
+            perfytd: (0, prelude_1.decimalFromNullable)(ev.perfytd),
+            perfstart: (0, prelude_1.decimalFromNullable)(ev.perfstart),
+            coefficient: (0, prelude_1.decimalFromNullable)(ev.coefficient),
+        }); }),
+        nav: (0, prelude_1.unsafeDecimal)(s.nav),
+        navAdjusted: (0, prelude_1.unsafeDecimal)(s.nav_adjusted),
+        navAdjustedTotal: (0, prelude_1.unsafeDecimal)(s.nav_adjusted_total),
+        coefficient: (0, prelude_1.unsafeDecimal)(s.coefficient),
+        gavRefccy: (0, prelude_1.unsafeDecimal)(s.gav_refccy),
+        gavClsccy: (0, prelude_1.unsafeDecimal)(s.gav_clsccy),
+        sharecountPrev: prelude_1.Maybe.fromNullable(s.sharecount_prev).map(prelude_1.unsafeDecimal),
+        sharecountCurr: prelude_1.Maybe.fromNullable(s.sharecount_curr).map(prelude_1.unsafeDecimal),
+        sharecountDiff: prelude_1.Maybe.fromNullable(s.sharecount_diff).map(prelude_1.unsafeDecimal),
+        pxRefCcy: (0, prelude_1.decimalFromNullable)(s.px_refccy),
+        pxClsCcy: (0, prelude_1.decimalFromNullable)(s.px_clsccy),
+        ytdExt: (0, prelude_1.decimalFromNullable)(s.ytdext),
+        ytdInt: (0, prelude_1.decimalFromNullable)(s.ytdint),
+    };
+}
+exports.toShareClassValue = toShareClassValue;
+/**
+ * Attempts to re-compile the raw, remote account valuation report and
+ * return it.
+ *
+ * @param x Raw, remote account valuation report.
+ * @returns Either of an error message or the re-compiled account valuation
+ * report.
+ */
+function recompileAccountValuationReport(x) {
+    // Attempt to get the base valuation report:
+    var baseReport = (0, _remote_valuation_report_shared_1.recompileBaseValuationReport)(x);
+    // Add consolidated valuation report specific fields and return:
+    return baseReport.map(function (report) {
+        return __assign(__assign({}, report), { account: x.account, subscriptions: (0, prelude_1.decimalFromNullable)(x.subscriptions).orDefault(prelude_1.zero), shareClassValues: x.scvals.map(toShareClassValue) });
+    });
+}
+exports.recompileAccountValuationReport = recompileAccountValuationReport;
+/**
+ * Attempts to retrieve remote account valuation report, compiles it to
+ * {@link AccountValuationReport} and return it.
+ *
+ * @param client DECAF Barista client.
+ * @param query Remote account valuation report endpoint query parameters.
+ * @returns Recompiled account valuation report data.
+ */
+function fetchAccountValuationReport(client, query) {
+    return __awaiter(this, void 0, void 0, function () {
+        var rawReport;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetchRemoteAccountValuationReport(client, query)];
+                case 1:
+                    rawReport = _a.sent();
+                    // Attempt to recompile the report (if any) and return:
+                    return [2 /*return*/, rawReport.chain(recompileAccountValuationReport)];
+            }
+        });
+    });
+}
+exports.fetchAccountValuationReport = fetchAccountValuationReport;

package/reports/valuation/-valuation-report-account.d.ts

@@ -0,0 +1,79 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { DecafActionId, CurrencyCode, DecafExternalValuationId, DecafOhlcSeriesId, DecafPortfolioId, DecafPrincipalId, DecafShareClassFeeScheduleId, DecafShareClassId } from '../../commons';
+import { BaseValuationReport, ValuationReportAccount } from './-valuation-report-shared';
+export interface AccountValuationReport extends BaseValuationReport {
+    account: ValuationReportAccount;
+    subscriptions: Decimal;
+    shareClassValues: AccountValuationReportShareClassValue[];
+}
+export interface AccountValuationReportShareClassValue {
+    shareclass: Maybe<AccountValuationReportShareClass>;
+    external: Maybe<AccountValuationReportExternalValue>;
+    nav: Decimal;
+    navAdjusted: Decimal;
+    navAdjustedTotal: Decimal;
+    coefficient: Decimal;
+    gavRefccy: Decimal;
+    gavClsccy: Decimal;
+    sharecountPrev: Maybe<Decimal>;
+    sharecountCurr: Maybe<Decimal>;
+    sharecountDiff: Maybe<Decimal>;
+    pxRefCcy: Maybe<Decimal>;
+    pxClsCcy: Maybe<Decimal>;
+    ytdExt: Maybe<Decimal>;
+    ytdInt: Maybe<Decimal>;
+}
+export interface AccountValuationReportShareClass {
+    id: DecafShareClassId;
+    created: SDateTime;
+    creator: Maybe<DecafPrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<DecafPrincipalId>;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin: Maybe<string>;
+    bbgticker: Maybe<string>;
+    liquidity: Maybe<string>;
+    jurisdiction: Maybe<string>;
+    administrator: Maybe<string>;
+    minimumInvestment: Maybe<number>;
+    subscriptionRedemptionPeriod: Maybe<string>;
+    managementFeeFrequency: Maybe<number>;
+    performanceFeeFrequency: Maybe<number>;
+    benchmark: Maybe<DecafOhlcSeriesId>;
+    description: Maybe<string>;
+    feeScheduleIds: DecafShareClassFeeScheduleId[];
+    effectiveFeeScheduleId: Maybe<DecafShareClassFeeScheduleId>;
+    subscriptionIds: DecafActionId[];
+    outstanding: Maybe<Decimal>;
+}
+export interface AccountValuationReportExternalValue {
+    id: DecafExternalValuationId;
+    created: SDateTime;
+    creator: Maybe<DecafPrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<DecafPrincipalId>;
+    guid: string;
+    portfolio: DecafPortfolioId;
+    shareclass: Maybe<DecafShareClassId>;
+    date: SDate;
+    ccy: CurrencyCode;
+    shares: Maybe<Decimal>;
+    price: Maybe<Decimal>;
+    nav: Maybe<Decimal>;
+    aum: Maybe<Decimal>;
+    hedgepnl: Maybe<Decimal>;
+    feemngt: Maybe<Decimal>;
+    feeperf: Maybe<Decimal>;
+    otheraccrued: Maybe<Decimal>;
+    totalaccrued: Maybe<Decimal>;
+    subred: Maybe<Decimal>;
+    perfdaily: Maybe<Decimal>;
+    perfweekly: Maybe<Decimal>;
+    perfmonthly: Maybe<Decimal>;
+    perfytd: Maybe<Decimal>;
+    perfstart: Maybe<Decimal>;
+    coefficient: Maybe<Decimal>;
+}

package/reports/valuation/-valuation-report-account.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/reports/valuation/-valuation-report-holdings-tree/-machinery.d.ts

@@ -1,10 +1,10 @@
 import { Decimal } from '@telostat/prelude';
 import { ValuationReportHolding, ValuationReportHoldingClassification } from '../-valuation-report-shared';
-import { ValuationReportHoldingsTreeNode, ValuationReportHoldingsTreeNodeValue } from './-types';
+import { AvailableAddresserKeys, ValuationReportHoldingsTreeNode, ValuationReportHoldingsTreeNodeValue } from './-types';
 export declare function makeValuationReportHoldingsTreeNodeValue(): ValuationReportHoldingsTreeNodeValue;
 export declare function updateTotals(nav: Decimal, investment: Decimal, tree: ValuationReportHoldingsTreeNode): ValuationReportHoldingsTreeNodeValue;
 export declare function resortChildren(node: ValuationReportHoldingsTreeNode): ValuationReportHoldingsTreeNode[];
 export declare function retreatTree(nav: Decimal, investment: Decimal, tree: ValuationReportHoldingsTreeNode): void;
 export declare function makeValuationReportHoldingsTreeNode(address: ValuationReportHoldingClassification): ValuationReportHoldingsTreeNode;
 export declare function addValuationReportHoldingToTree(tree: ValuationReportHoldingsTreeNode, address: ValuationReportHoldingClassification, holding: ValuationReportHolding): void;
-export declare function makeValuationReportHoldingsTree(nav: Decimal, investment: Decimal, holdings: ValuationReportHolding[]): ValuationReportHoldingsTreeNode;
+export declare function makeValuationReportHoldingsTree(nav: Decimal, investment: Decimal, holdings: ValuationReportHolding[], addressKey?: AvailableAddresserKeys): ValuationReportHoldingsTreeNode;

package/reports/valuation/-valuation-report-holdings-tree/-machinery.js

@@ -165,8 +165,9 @@ function addValuationReportHoldingToTree(tree, address, holding) {
     node.holdings.push(holding);
 }
 exports.addValuationReportHoldingToTree = addValuationReportHoldingToTree;
-function makeValuationReportHoldingsTree(nav, investment, holdings) {
+function makeValuationReportHoldingsTree(nav, investment, holdings, addressKey) {
     var e_2, _a;
+    if (addressKey === void 0) { addressKey = 'classification'; }
     // Initialize the tree:
     var tree = makeValuationReportHoldingsTreeNode([]);
     tree.name = '« Total »';
@@ -174,7 +175,9 @@ function makeValuationReportHoldingsTree(nav, investment, holdings) {
         // Iterate over the holdings and attempt to add to the tree:
         for (var holdings_1 = __values(holdings), holdings_1_1 = holdings_1.next(); !holdings_1_1.done; holdings_1_1 = holdings_1.next()) {
             var holding = holdings_1_1.value;
-            addValuationReportHoldingToTree(tree, holding.classification, holding);
+            // Get the address of the holding:
+            var address = _utils_1.addressers[addressKey](holding);
+            addValuationReportHoldingToTree(tree, address, holding);
         }
     }
     catch (e_2_1) { e_2 = { error: e_2_1 }; }

package/reports/valuation/-valuation-report-holdings-tree/-types.d.ts

@@ -21,3 +21,6 @@ export interface ValuationReportHoldingsTreeNodeValue {
     pnl: Decimal;
     pnlRatio: Decimal;
 }
+export type HoldingAddress = ValuationReportHoldingClassification;
+export type HoldingAddresser = (holding: ValuationReportHolding) => HoldingAddress;
+export type AvailableAddresserKeys = 'classification' | 'currency' | 'country' | 'issuer' | 'sector';

package/reports/valuation/-valuation-report-holdings-tree/-utils.d.ts

@@ -1 +1,7 @@
+import { Maybe } from '@telostat/prelude';
+import { ValuationReportHolding } from '../-valuation-report-shared';
+import { AvailableAddresserKeys, HoldingAddresser } from './-types';
 export declare function compareStringArrays(x: string[], y: string[]): number;
+export declare function composeHoldingAddressers(addressers: Array<HoldingAddresser>): HoldingAddresser;
+export declare function makeSimpleAddresser(def: string, labeler: (holding: ValuationReportHolding) => Maybe<string>): HoldingAddresser;
+export declare const addressers: Record<AvailableAddresserKeys, HoldingAddresser>;

package/reports/valuation/-valuation-report-holdings-tree/-utils.js

@@ -1,6 +1,31 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareStringArrays = void 0;
+exports.addressers = exports.makeSimpleAddresser = exports.composeHoldingAddressers = exports.compareStringArrays = void 0;
 function compareStringArrays(x, y) {
     var xLen = x.length;
     var yLen = y.length;
@@ -14,3 +39,36 @@ function compareStringArrays(x, y) {
     return Math.sign(xLen - yLen);
 }
 exports.compareStringArrays = compareStringArrays;
+function composeHoldingAddressers(addressers) {
+    return function (holding) {
+        return addressers.reduce(function (p, c) { return __spreadArray(__spreadArray([], __read(p), false), __read(c(holding)), false); }, []);
+    };
+}
+exports.composeHoldingAddressers = composeHoldingAddressers;
+function makeSimpleAddresser(def, labeler) {
+    return function (holding) {
+        // Attempt to get the label:
+        var label = labeler(holding).orDefault('') || def;
+        // Get the value:
+        var value = label.toUpperCase();
+        // Done, return:
+        return [{ name: value, order: value }];
+    };
+}
+exports.makeSimpleAddresser = makeSimpleAddresser;
+exports.addressers = {
+    classification: function (holding) {
+        // Get the classification:
+        var classification = holding.classification;
+        // Build the address and return:
+        return classification.map(function (x) { return ({
+            // label: x.name,
+            name: x.name.toUpperCase(),
+            order: "".concat(x.order).toUpperCase(),
+        }); });
+    },
+    currency: makeSimpleAddresser('[Undefined Currency]', function (holding) { return holding.artifact.ccy; }),
+    country: makeSimpleAddresser('[Undefined Country]', function (holding) { return holding.artifact.country; }),
+    issuer: makeSimpleAddresser('[Undefined Issuer]', function (holding) { return holding.artifact.issuer; }),
+    sector: makeSimpleAddresser('[Undefined Sector]', function (holding) { return holding.artifact.sector; }),
+};

package/reports/valuation/index.d.ts

@@ -2,7 +2,10 @@ export { fetchConsolidatedValuationReport } from './-remote-valuation-report-con
 export type { ConsolidatedValuationReportQuery } from './-remote-valuation-report-consolidated';
 export { fetchPortfolioValuationReport } from './-remote-valuation-report-portfolio';
 export type { PortfolioValuationReportQuery } from './-remote-valuation-report-portfolio';
+export { fetchAccountValuationReport } from './-remote-valuation-report-account';
+export type { AccountValuationReportQuery } from './-remote-valuation-report-account';
 export * from './-valuation-report-consolidated';
 export * from './-valuation-report-holdings-tree';
 export * from './-valuation-report-portfolio';
 export * from './-valuation-report-shared';
+export * from './-valuation-report-account';

package/reports/valuation/index.js

@@ -14,12 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchPortfolioValuationReport = exports.fetchConsolidatedValuationReport = void 0;
+exports.fetchAccountValuationReport = exports.fetchPortfolioValuationReport = exports.fetchConsolidatedValuationReport = void 0;
 var _remote_valuation_report_consolidated_1 = require("./-remote-valuation-report-consolidated");
 Object.defineProperty(exports, "fetchConsolidatedValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_consolidated_1.fetchConsolidatedValuationReport; } });
 var _remote_valuation_report_portfolio_1 = require("./-remote-valuation-report-portfolio");
 Object.defineProperty(exports, "fetchPortfolioValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_portfolio_1.fetchPortfolioValuationReport; } });
+var _remote_valuation_report_account_1 = require("./-remote-valuation-report-account");
+Object.defineProperty(exports, "fetchAccountValuationReport", { enumerable: true, get: function () { return _remote_valuation_report_account_1.fetchAccountValuationReport; } });
 __exportStar(require("./-valuation-report-consolidated"), exports);
 __exportStar(require("./-valuation-report-holdings-tree"), exports);
 __exportStar(require("./-valuation-report-portfolio"), exports);
 __exportStar(require("./-valuation-report-shared"), exports);
+__exportStar(require("./-valuation-report-account"), exports);