bharosa 0.0.0-stage → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# 0.3.0 — local keys-only release candidate (unpublished)
+
+Adds server-side BharosaMarket for four registered-app monthly snapshot operations, with no investor token/account argument. Requires separately activated API market_key support. Includes lifecycle0.2.0 changes; no unpublished analytics methods. Version0.3.0 was absent from npm at preparation, not reserved there.
+
+# Changelog
+
+## 0.2.0 — 30 October 2026
+
+- Add `portfolios.update(id, { name, expected_name }, { idempotencyKey })` for account-scoped, name-only updates, with optimistic name comparison and validated response identity. Holdings and snapshots remain unchanged.
+- Accept `positions: []` when creating a saved portfolio. Empty portfolio analysis remains unavailable until holdings exist.
+- Clarify that monthly market reads require authenticated account-read access without a separate market-data approval.
+- Preserve existing methods, exports, authentication, quantity precision, and analytics implementation. Requires a companion API with portfolio lifecycle support; package preparation does not establish production availability.
+
+The entries below retain historical preparation notes from the published 0.1.0 package. They are not additional changes in 0.2.0.
+
+## 0.1.0 — release candidate
+
+Prepared for the first npm release; publication is pending registry authentication and verification. API deployment and external consent activation are separate.
+
+- Typed Node.js client with ESM/CommonJS exports, account-scoped direct/delegated authentication, and 17 public resource operations.
+- Portfolio asset, sector, and issuer mix methods for saved and in-memory targets, with MutualFund conveniences delegated to their underlying Portfolio.
+- Object conveniences: `portfolios.build`, immutable readable in-memory positions, and saved `Portfolio.currentSnapshot`; `fromPositions` remains compatible. No additional HTTP endpoints.
+- Typed errors, explicit mutation outcomes, bounded opt-in retries, total request deadlines, response validation, and browser rejection.
+- MIT license for the SDK, standalone guides, synthetic examples, contributor tooling, and CI configuration. The API and analytics implementation remain separate and closed source.
+
+## Unreleased — TypeScript source migration
+
+- Author the client and behavioral tests in strict TypeScript and emit declarations from implementation.
+- Preserve resource methods, runtime validation, caller-owned transport and CommonJS/ESM package entry points.
+- Keep runtime dependencies empty; TypeScript and Node definitions are development-only tooling.
+
+Units-first portfolio creation (local, unreleased): `portfolios.create` accepts an initial position with either `current_value` or positive `quantity`, never both, using the supplied `as_of` date. Existing amount requests and amount-only responses remain unchanged. Supplied units are stored atomically without requiring a NAV. Snapshot `quantity` can now be a decimal string and `valuation` can be null; `total_current_value` is null when any snapshot position lacks a reported amount, and `valuation_basis` is `supplied_quantity`. Consumers of general snapshot reads must handle these new nullable values; this is an intentional prelaunch type widening. Older SDKs cannot read units-only snapshots. Snapshot replacement and in-memory analytics remain amount-only. No public package release or availability change is implied.
+
+Unit precision follow-up (local, unreleased): supplied units accept at most four fractional digits; additional digits are rejected, never truncated. Dated amount conversion rounds once to four places using decimal half-even arithmetic; a positive amount rounding to zero returns `units_below_precision`. Currency and NAV precision are unchanged. Exact historical quantities and provenance remain in stored evidence and read responses; the web marks rounded displays with ≈, shows tiny positive values as <0.0001, and makes a rounded edit draft an explicit correction. Existing zero-unit closure remains supported; initial quantities must be positive. No portfolio reset or data rewrite is required. Canonical marketing reconciliation is coordinated through the parent, with deployment pending.
+
+Local readiness: reject inconsistent resource pagination responses and discard late custom-transport bodies after cancellation. No operation shapes, credentials, access or availability changed.
+
+Local attendee readiness: browser-condition ESM now selects the explicit ESM entry point; packed tests exercise both browser ESM and CJS. The installed archive includes a credential-free offline smoke script. README startup checks identify missing environment variable names without exposing values. No live endpoint, access or publication is implied.

package/CONTRACT-SHA256

@@ -0,0 +1 @@
+3b791799bf705fd36a257e27a2520257f135e772d617b03bb22063ccea4d04e2  marketing/contracts/openapi.json

package/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing
+
+This is an unpublished SDK under local preparation. Keep changes limited to the client, public contracts, documentation, and synthetic tests. Do not copy API implementation, analytics code, provider data, credentials, or internal operational notes into this repository.
+
+## Development
+
+Use supported Node.js 22.12+ or 24 LTS. Runtime dependencies remain empty. Contributor TypeScript tooling lives in `tooling/` and is separate from the distributable package.
+
+```sh
+npm --prefix tooling ci --ignore-scripts
+node scripts/check-generated.mjs
+npm run build
+npm test
+node scripts/check-local-examples.mjs
+node scripts/verify-package.mjs
+```
+
+The unit suite uses synthetic responses. One HTTP regression opens ephemeral loopback ports to verify redirect protection. It does not use live credentials or a live Bharosa service. Packed-consumer verification writes to temporary directories and installs only the local tarball.
+
+`node scripts/verify-package.mjs` uses the pinned tooling compiler by default. `BHAROSA_TSC` can select an already-installed compiler for compatibility checks. `npm test` builds, strictly typechecks runtime and tests, checks compatibility with the previous public declarations, then runs the compiled tests against `dist/`.
+
+## Contracts and generated files
+
+`test/openapi.json` is the public contract snapshot; `scripts/generate.mjs` derives runtime schemas, model type source, and the contract digest. Change the canonical public contract with its owner first, then update the snapshot and regenerate. Review generated changes; never copy private service source to recreate them.
+
+For a behavior change, add a regression that demonstrates the user's observable outcome. Check both JavaScript and TypeScript consumers. Update the relevant guide and examples. In the Bharosa workspace, coordinate corresponding marketing guides, capability/endpoint registry, examples, changelog, and reviewed source hashes with the marketing owner. Local verification does not establish deployed availability.
+
+## Review hygiene
+
+Use small, logical commits with accurate author attribution. Keep unrelated changes separate. Review staged files and package contents for credentials, personal data, and private source. Internal handoff notes and build archives should stay local and untracked. Preserve third-party notices and document any new dependency's license and purpose.
+
+Report security concerns privately using the process in [SECURITY.md](SECURITY.md).
+
+## TypeScript implementation
+
+Authored runtime modules are in `src/*.cts`; the ESM entry point is `src/index.mts`. `npm run build` compiles them with strict TypeScript and emits JavaScript plus declarations into ignored `dist/`. Public declarations come from this source, not a separately maintained client declaration file. CommonJS, ESM and browser-condition consumers use the same runtime.
+
+Behavioral tests in `test/*.test.ts` are strictly compiled before execution. Synthetic JSON fixtures remain data. Tests deliberately exercising malformed JavaScript calls use checked reflective helpers; valid consumer examples and the frozen pre-migration API surface are checked separately. Do not use blanket `any` or disable compiler checks to make a migration pass.
+
+The contract generators continue to own runtime schema data. TypeScript compilation does not replace network response validation. All credentials, session handling and first-party authorization remain the responsibility of the caller's transport and the server. No private service implementation belongs here.

package/FIRST-PARTY-CONTRACT-SHA256

@@ -0,0 +1 @@
+1df18aec81ec3a525dda9cc25190f2db5fee7776e7422d2a456688ee12656d9f

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bharosa Technoserve Private Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MONTHLY-MARKET-CONTRACT-SHA256

@@ -0,0 +1 @@
+ad8f930964df34c3a28e3309302d19ba76ab9d48190c024a26b0795422f0b648

package/README.md

@@ -1,3 +1,129 @@
-# Temporary Holding Version
+# Bharosa SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A TypeScript client for Bharosa accounts, investors, portfolios, and mutual funds. Use one resource interface from TypeScript, ESM, or CommonJS, with no runtime dependencies.
+
+**Release target:** `bharosa@0.1.0`. Registry publication is pending; use the reviewed local archive until publication is confirmed. You also need an API URL and credentials from the operator of your Bharosa service; installing the SDK does not create an account or grant access.
+
+## Start here
+
+Use Node.js 22.12+ in a supported LTS release. If you have the source checkout, build and pack it:
+
+```sh
+npm --prefix tooling ci --ignore-scripts
+npm run build
+npm pack --pack-destination /absolute/path/to/artifacts
+```
+
+If the operator supplied a reviewed archive, skip the source build. Install that archive in your backend application:
+
+```sh
+npm install /absolute/path/to/artifacts/bharosa-0.1.0.tgz
+```
+
+Configure your application's API origin, account ID, and account key through its secret manager. Then:
+
+```ts
+import { Bharosa } from "bharosa";
+
+function required(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Missing ${name}`);
+  return value;
+}
+const bharosa = new Bharosa({
+  baseUrl: required("BHAROSA_API_BASE_URL"),
+  account: required("BHAROSA_ACCOUNT_ID"),
+  auth: { type: "account_key", apiKey: required("BHAROSA_SECRET_KEY") },
+});
+const account = await bharosa.accounts.retrieve();
+```
+
+The startup check names missing environment variables without printing their values. See the [complete setup guide](docs/getting-started.md) for explicit checks and delegated authentication. CommonJS uses `const { Bharosa } = require("bharosa")`.
+
+## Calculate a saved portfolio's mix
+
+A client is a person or family group, such as the Rao family. An investor is one
+member of that group. Each investor can have several saved portfolios; there is
+no automatic "current portfolio" selection.
+
+List families with `bharosa.clients.list()`, then list their members with
+`bharosa.investors.list({ client: family.id })`. List portfolios with
+`bharosa.portfolios.list({ client: family.id })` and keep those whose `investor`
+field matches the selected member's ID. Let the user choose a portfolio, and
+pass its returned ID to this function:
+
+```ts
+async function savedPortfolioMix(portfolioId: string) {
+  const portfolio = await bharosa.portfolios.retrieve(portfolioId);
+  const snapshot = await portfolio.currentSnapshot();
+  const asset = await portfolio.assetMix();
+  return { snapshot, asset };
+}
+```
+
+Follow `has_more` and `startingAfter` when listing resources. Do not select the
+first result or match only by a family name: names need not be unique. See the
+[complete selection example](examples/portfolio-mixes.ts).
+
+The saved mix uses the values and date in the portfolio's current saved snapshot.
+It does not automatically reprice later holding-unit observations using today's
+NAV. `asOf` changes the date used to look up the funds' underlying holdings; it
+does not change the investor's positions or their valuation date.
+
+For a fund, search first and let the user select the matching share class:
+
+```ts
+const matches = await bharosa.mutualFunds.search({ query: "equity" });
+// Display matches.data and let the user choose the intended fund/plan.
+// The returned instrument exposes assetMix(), sectorMix() and issuerMix().
+```
+
+Use returned IDs rather than inventing them. The API calculates each mix; the SDK
+makes the request. Asset percentages can be negative or above 100. Sector and
+issuer mixes cover equities only. Keep the response's dates, warnings and
+availability status alongside the numbers.
+
+Read the [portfolio guide](docs/portfolios.md), or run the
+[examples with simulated responses](examples/README.md) without live credentials.
+
+## Read and build resources
+
+`portfolios.build(...)` creates an in-memory calculation handle with a readable, immutable `positions` collection. It defensively copies supplied positions; changes to your original input cannot change future requests. `fromPositions(...)` remains an equivalent alias. Use `portfolios.create(...)` when you intend to persist a portfolio.
+
+A saved portfolio has `currentSnapshot()` to retrieve its current snapshot using the existing snapshot API. A fund's `portfolio` is a calculation handle, not a downloaded holdings collection. Sector and issuer methods cover equity-only allocation.
+
+The SDK also supports account reads, client lists, investor creation/updates, snapshot replacement, and mutual-fund discovery. Body and response fields use snake_case. Monetary values remain decimal strings. Lists use `limit` and `startingAfter`; investor/portfolio lists can filter by `client`. Root exports include TypeScript models and typed error classes.
+
+Saved portfolios also expose scoped `holdings` and declared `history`. Use `holding.positionOn(date)` for dated evidence and `portfolio.on(date).assetMix({ valuationDate, asOf })` for strict server-side historical calculation. See [dated positions and declared history](docs/portfolios.md#dated-positions-and-declared-history) for completeness, exact-date valuation and supported-event limits. These methods do not move calculation code into the SDK.
+
+## Reliability and security
+
+Keep credentials in a backend or a server that handles browser sessions. Account-key and delegated authentication are server-only. Browser applications can use a caller-owned transport; the host application owns session handling, same-origin enforcement and CSRF. Bun and Deno are unsupported. Clients are immutable and account-scoped. The SDK does not provision access, start consent, or refresh tokens.
+
+Requests have a total 30-second timeout by default and zero retries unless requested. Creates require an idempotency key. A failed mutation can have an `unknown` outcome even if the server committed it. Use the [reliability guide](docs/reliability.md) to handle retries, cancellation, and reconciliation correctly.
+
+Report vulnerabilities privately using [SECURITY.md](SECURITY.md).
+
+## Develop and contribute
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for reproducible tooling, synthetic tests, and packed-consumer verification. The [release checklist](docs/releasing.md) separates source publication from npm publication. The package is configured to prevent accidental npm publication.
+
+## License and scope
+
+[MIT](LICENSE) — Copyright (c) 2026 Bharosa Technoserve Private Limited.
+
+The license covers this SDK. The Bharosa API service, analytics implementation, ingestion adapters, and provider datasets are separate and are not included or licensed by this repository.
+
+### Monthly market history and synthetic samples
+
+`client.marketSnapshots` exposes month-start historical market observations and latest NAV valuation without a separate market-data approval step, using authenticated credentials with the required account-read scope. All external credentials, including direct account keys, use monthly historical market dates; investor transaction and position history retains its full dates. See [monthly snapshots](docs/monthly-market-data.md) for actual observation dates, missing data and availability. This local implementation does not activate live access.
+
+The optional `bharosa/testing` entrypoint supplies fresh, deterministic synthetic portfolios and fictional fund compositions without credentials or network requests. Its seed helper writes only when explicitly called with an authenticated client, confirmed test account, stable run ID and resolved instrument mapping. See [testing samples](docs/testing.md).
+
+Unit precision follow-up (local, unreleased): supplied units accept at most four fractional digits; additional digits are rejected, never truncated. Dated amount conversion rounds once to four places using decimal half-even arithmetic; a positive amount rounding to zero returns `units_below_precision`. Currency and NAV precision are unchanged. Exact historical quantities and provenance remain in stored evidence and read responses; the web marks rounded displays with ≈, shows tiny positive values as <0.0001, and makes a rounded edit draft an explicit correction. Existing zero-unit closure remains supported; initial quantities must be positive. No portfolio reset or data rewrite is required. Canonical marketing reconciliation is coordinated through the parent, with deployment pending.
+
+After installing the archive, run `node node_modules/bharosa/examples/offline-smoke.mjs` for a credential-free synthetic read. This checks installed imports and the transport path without contacting Bharosa or creating data. It does not prove live access. Source-checkout verification commands require contributor files that are intentionally excluded from the runtime archive.
+
+### Local candidate: registered-app monthly data
+
+Not published or activated. Server applications can use `new BharosaMarket({baseUrl, apiKey})` with an owner-issued `market_key` scoped only to `market:read`. `client.schemes.nav(id,{asOf:'2026-08-01'})`, `schemes.expenseRatio`, `funds.portfolio` and `funds.holdings` use account-independent monthly snapshot routes. These keys cannot read private accounts or portfolios and require no investor OAuth token. Keep secrets server-side; never bundle them into browser code. Existing account-key and delegated-user clients remain unchanged. A separately versioned release and explicit API activation are required.

package/SECURITY.md

@@ -0,0 +1,11 @@
+# Security reporting
+
+Do not include credentials, customer records, financial account data, or exploit details in a public issue or pull request.
+
+Before opening this repository to the public, maintainers must enable private vulnerability reporting through the repository's Security advisories and verify that reports reach the responsible maintainer. A verified private reporting channel is a release prerequisite. No reporting email or response-time commitment is established here.
+
+Once enabled, use **Security → Report a vulnerability** for a private report. If that option is absent, do not post sensitive details publicly; ask the repository maintainer to enable private reporting first.
+
+Include the affected SDK version/runtime, a minimal synthetic reproduction, expected and observed behavior, and impact. Redact tokens, keys, account identifiers, and customer data. No live service access is required to demonstrate most SDK issues.
+
+There are no publicly released supported SDK versions yet. Version support and a security maintenance policy must be established before the first public package release.

package/dist/browser.cjs

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const sdk = __importStar(require("./index.cjs"));
+module.exports = sdk;

package/dist/browser.d.cts

@@ -0,0 +1,2 @@
+import * as sdk from "./index.cjs";
+export = sdk;

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+import * as sdk from "./index.js";
+export = sdk;

package/dist/client-types.cjs

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

package/dist/client-types.d.cts

@@ -0,0 +1,229 @@
+import type { MonthlyMarketClient } from "./monthly-types.cjs";
+import type { MarketDataClient, CurrentHoldingsInput, CurrentHoldingsResult } from "./market-types.cjs";
+export type * from "./market-types.cjs";
+import type { Holding, HoldingPosition, HistoryCapability, HistoryView, HistoryImport, HistoryImportResult, HoldingsList, AssetMix, SectorMix, IssuerMix, PositionInput, Account, Client, ClientsList, Investor, InvestorsList, InvestorCreate, InvestorUpdate, Portfolio, PortfoliosList, PortfolioCreate, PortfolioUpdate, SnapshotCreate, SnapshotView, FundsList, FundReferences } from "./models.cjs";
+export type * from "./models.cjs";
+export type Auth = {
+    readonly type: "account_key";
+    readonly apiKey: string;
+    readonly userAccessToken?: never;
+} | {
+    readonly type: "delegated_application";
+    readonly apiKey: string;
+    readonly userAccessToken: string;
+};
+/** Trusted caller-owned transport. Authentication, session handling and origin policy belong to the host application. */
+export interface BharosaTransport {
+    send(url: string, request: RequestInit): Promise<Response>;
+}
+interface BharosaBaseConfig {
+    readonly baseUrl: string;
+    readonly account: string;
+    readonly allowLocalhostHttp?: boolean;
+    readonly maxResponseBytes?: number;
+}
+export type BharosaConfig = BharosaBaseConfig & ({
+    readonly auth: Auth;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly transport?: never;
+} | {
+    readonly transport: BharosaTransport;
+    readonly auth?: never;
+    readonly fetch?: never;
+});
+export interface RequestOptions {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxRetries?: 0 | 1 | 2;
+}
+export interface IdempotentOptions extends RequestOptions {
+    idempotencyKey: string;
+}
+export interface ListOptions {
+    limit?: number;
+    startingAfter?: string;
+}
+export interface FilteredListOptions extends ListOptions {
+    client?: string;
+}
+export interface PortfolioListOptions extends ListOptions {
+    /** Compatibility alias; cannot be combined with plural filters. */
+    client?: string;
+    client_ids?: string[];
+    investor_ids?: string[];
+}
+export type MutationOutcome = "not_applicable" | "not_sent" | "rejected" | "unknown";
+export interface MixOptions {
+    asOf?: string;
+}
+export interface PortfolioMethods {
+    assetMix(params?: MixOptions, options?: RequestOptions): Promise<AssetMix>;
+    sectorMix(params?: MixOptions, options?: RequestOptions): Promise<SectorMix>;
+    issuerMix(params?: MixOptions, options?: RequestOptions): Promise<IssuerMix>;
+}
+export interface InMemoryPortfolioInput {
+    valuationDate: string;
+    currency?: "INR";
+    positions: ReadonlyArray<Readonly<PositionInput>>;
+}
+export interface DatedPortfolioMethods {
+    assetMix(params?: MixOptions & {
+        valuationDate?: string;
+    }, options?: RequestOptions): Promise<AssetMix>;
+    sectorMix(params?: MixOptions & {
+        valuationDate?: string;
+    }, options?: RequestOptions): Promise<SectorMix>;
+    issuerMix(params?: MixOptions & {
+        valuationDate?: string;
+    }, options?: RequestOptions): Promise<IssuerMix>;
+    on(date: string): DatedPortfolioMethods;
+}
+export type HoldingObject = Holding & {
+    positionOn(date: string, options?: RequestOptions): Promise<HoldingPosition>;
+};
+export interface InMemoryPortfolio extends PortfolioMethods {
+    on(date: string): DatedPortfolioMethods;
+    readonly positions: ReadonlyArray<Readonly<PositionInput>>;
+}
+export interface CurrentPortfolioMethods {
+    assetMix(params?: Record<string, never>, options?: RequestOptions): Promise<AssetMix & CurrentMixEvidence>;
+    sectorMix(params?: Record<string, never>, options?: RequestOptions): Promise<SectorMix & CurrentMixEvidence>;
+    issuerMix(params?: Record<string, never>, options?: RequestOptions): Promise<IssuerMix & CurrentMixEvidence>;
+}
+export interface CurrentMixEvidence {
+    current_valuation: {
+        valuation_date: string;
+        holdings: Array<{
+            holding: string;
+            investment_account: string;
+            instrument: string;
+            scheme_id: string;
+            status: "available";
+            units: string;
+            as_of: string;
+            position_date: string;
+            value: {
+                amount: string;
+                currency: "INR";
+            };
+            nav: {
+                amount: string;
+                currency: "INR";
+                date: string;
+            };
+            freshness: {
+                status: "recent" | "stale";
+                age_days: number;
+                recent_within_days: 3;
+                time_zone: "Asia/Kolkata";
+            };
+            ownership_status: "user_supplied_not_verified";
+            valuation_basis: "units_times_latest_nav";
+            revision: number | null;
+            source: {
+                kind: "user" | "statement";
+                reference: string;
+            };
+            derivation: import("./market-types.cjs").CurrentHoldingsResult["holdings"][number]["derivation"] | null;
+        }>;
+    };
+}
+export type PortfolioObject = Portfolio & PortfolioMethods & {
+    current(): CurrentPortfolioMethods;
+    currentSnapshot(options?: RequestOptions): Promise<SnapshotPortfolioView>;
+    on(date: string): DatedPortfolioMethods;
+    readonly history: {
+        retrieve(options?: RequestOptions): Promise<HistoryView>;
+        import(body: HistoryImport, options: IdempotentOptions): Promise<HistoryImportResult>;
+        canReconstruct(date: string, options?: RequestOptions): Promise<HistoryCapability>;
+    };
+    readonly holdings: {
+        setCurrent(body: CurrentHoldingsInput, options: IdempotentOptions): Promise<CurrentHoldingsResult>;
+        retrieve(holding: string, options?: RequestOptions): Promise<HoldingObject>;
+        list(params?: {
+            date?: string;
+        }, options?: RequestOptions): Promise<Omit<HoldingsList, "data"> & {
+            data: HoldingObject[];
+        }>;
+    };
+};
+type Fields<T> = {
+    [K in keyof T as string extends K ? never : K]: T[K];
+};
+export type SnapshotPortfolioView = Omit<Fields<SnapshotView>, "portfolio"> & {
+    portfolio: PortfolioObject;
+};
+export type PortfolioObjectsList = Omit<Fields<PortfoliosList>, "data"> & {
+    data: PortfolioObject[];
+};
+export interface MutualFundObject extends PortfolioMethods {
+    readonly portfolio: PortfolioMethods;
+    readonly mutual_fund_id?: string;
+    readonly instrument?: string;
+}
+export type FundObjectsList = Omit<Fields<FundsList>, "data"> & {
+    data: Array<FundsList["data"][number] & {
+        instrument: FundsList["data"][number]["instrument"] & MutualFundObject;
+    }>;
+};
+export type FundObjectReferences = Omit<Fields<FundReferences>, "data"> & {
+    data: Array<FundReferences["data"][number] & {
+        instrument: FundReferences["data"][number]["instrument"] & MutualFundObject;
+    }>;
+};
+export interface ClientSurface {
+    readonly marketSnapshots: MonthlyMarketClient;
+    readonly mutualFundSchemes: {
+        readonly navs: {
+            readonly retrieve: MonthlyMarketClient["schemes"]["nav"];
+        };
+        readonly expenseRatios: {
+            readonly retrieve: MonthlyMarketClient["schemes"]["expenseRatio"];
+        };
+        readonly valuation: MonthlyMarketClient["schemes"]["valuation"];
+    };
+    readonly marketData: MarketDataClient;
+    readonly accounts: {
+        readonly retrieve: (options?: RequestOptions) => Promise<Account>;
+    };
+    readonly clients: {
+        readonly list: (params?: ListOptions, options?: RequestOptions) => Promise<ClientsList>;
+        readonly retrieve: (id: string, options?: RequestOptions) => Promise<Client>;
+    };
+    readonly investors: {
+        readonly list: (params?: FilteredListOptions, options?: RequestOptions) => Promise<InvestorsList>;
+        readonly retrieve: (id: string, options?: RequestOptions) => Promise<Investor>;
+        readonly create: (body: InvestorCreate, options: IdempotentOptions) => Promise<Investor>;
+        readonly update: (id: string, body: InvestorUpdate, options?: RequestOptions) => Promise<Investor>;
+    };
+    readonly portfolios: {
+        readonly update: (id: string, body: PortfolioUpdate, options: IdempotentOptions) => Promise<PortfolioObject>;
+        readonly build: (input: InMemoryPortfolioInput) => InMemoryPortfolio;
+        readonly fromPositions: (input: InMemoryPortfolioInput) => InMemoryPortfolio;
+        readonly list: (params?: PortfolioListOptions, options?: RequestOptions) => Promise<PortfolioObjectsList>;
+        readonly retrieve: (id: string, options?: RequestOptions) => Promise<PortfolioObject>;
+        readonly create: (body: PortfolioCreate, options: IdempotentOptions) => Promise<SnapshotPortfolioView>;
+        readonly snapshots: {
+            readonly retrieveCurrent: (id: string, options?: RequestOptions) => Promise<SnapshotPortfolioView>;
+            readonly create: (id: string, body: SnapshotCreate, options: IdempotentOptions) => Promise<SnapshotPortfolioView>;
+        };
+    };
+    readonly mutualFunds: {
+        readonly portfolios: {
+            readonly retrieve: MonthlyMarketClient["funds"]["portfolio"];
+            readonly holdings: {
+                readonly list: MonthlyMarketClient["funds"]["holdings"];
+            };
+        };
+        readonly fromId: (mutualFundId: string) => MutualFundObject;
+        readonly fromInstrument: (instrument: string) => MutualFundObject;
+        readonly search: (params: {
+            query: string;
+            limit?: number;
+        }, options?: RequestOptions) => Promise<FundObjectsList>;
+        readonly references: (params: {
+            instruments: string[];
+        }, options?: RequestOptions) => Promise<FundObjectReferences>;
+    };
+}