@fintekkers/ledger-models 0.1.132 → 0.1.134

package/node/wrappers/models/security/security.test.ts

@@ -3,9 +3,11 @@ import { UUID } from '../utils/uuid';
 
 import assert = require('assert');
 import Security from './security';
+import BondSecurity from './BondSecurity';
 
 import { DecimalValueProto } from '../../../fintekkers/models/util/decimal_value_pb';
 import { SecurityProto } from '../../../fintekkers/models/security/security_pb';
+import { SecurityTypeProto } from '../../../fintekkers/models/security/security_type_pb';
 import { CouponFrequencyProto } from '../../../fintekkers/models/security/coupon_frequency_pb';
 import { CouponTypeProto } from '../../../fintekkers/models/security/coupon_type_pb';
 import { SecurityQuantityTypeProto } from '../../../fintekkers/models/security/security_quantity_type_pb';
@@ -21,6 +23,52 @@ function testSerialization(): void {
     assert(security.getMaturityDate().toDate().getFullYear() == 2026);
 }
 
+test('equity routes to base Security and isBond() returns false', () => {
+    const equity = dummyEquity();
+    expect(equity).toBeInstanceOf(Security);
+    expect(equity).not.toBeInstanceOf(BondSecurity);
+    expect(equity.isBond()).toBe(false);
+});
+
+test('bond routes to BondSecurity and isBond() returns true (narrows type)', () => {
+    const bond = dummyBondSecurity();
+    expect(bond.isBond()).toBe(true);
+    if (bond.isBond()) {
+        // Inside the narrowed branch TS knows bond: BondSecurity.
+        // Calling a BondSecurity-only method here proves the narrowing works.
+        expect(bond.getCouponRate()).toBeDefined();
+    }
+});
+
+test('Security.getIssueDate returns null on equity (no throw)', () => {
+    const equity = dummyEquity();
+    // Phase 1 behavior change: was throw "Issue date is required", now returns null.
+    // This is the symptom fix that motivated #205 — equity wrappers no longer
+    // explode on per-record post-processing in ui-service.
+    expect(equity.getIssueDate()).toBeNull();
+});
+
+test('BondSecurity.getIssueDate returns LocalDate (non-nullable) on bond', () => {
+    const bond = dummyBondSecurity();
+    if (!bond.isBond()) throw new Error('test setup: expected bond');
+    const issueDate = bond.getIssueDate();
+    expect(issueDate).not.toBeNull();
+    expect(issueDate.toDate().getFullYear()).toBe(2021);
+});
+
+test('Security.getMaturityDate still throws on equity (Phase 1 deprecation, not removal)', () => {
+    const equity = dummyEquity();
+    // Behavior preserved deliberately for Phase 1 — callers still get a
+    // loud error if they don't narrow first. Removal happens in Phase 2.
+    expect(() => equity.getMaturityDate()).toThrow('Maturity date is required');
+});
+
+test('BondSecurity.getMaturityDate works on bond (inherited from Security)', () => {
+    const bond = dummyBondSecurity();
+    if (!bond.isBond()) throw new Error('test setup: expected bond');
+    expect(bond.getMaturityDate().toDate().getFullYear()).toBe(2026);
+});
+
 function dummySecurity() {
     return Security.create(new SecurityProto()
         .setObjectClass('Transaction').setVersion('0.0.1').setUuid(UUID.random().toUUIDProto())
@@ -39,3 +87,35 @@ function dummySecurity() {
     );
 }
 
+function dummyBondSecurity() {
+    // Same dummy security but with securityType set so the factory routes
+    // to BondSecurity.
+    return Security.create(new SecurityProto()
+        .setObjectClass('Security').setVersion('0.0.1').setUuid(UUID.random().toUUIDProto())
+        .setSecurityType(SecurityTypeProto.BOND_SECURITY)
+        .setFaceValue(new DecimalValueProto().setArbitraryPrecisionValue('1000.00'))
+        .setQuantityType(SecurityQuantityTypeProto.ORIGINAL_FACE_VALUE)
+        .setAssetClass("Bond")
+        .setIssuerName("Dummy issuer")
+        .setCouponRate(new DecimalValueProto().setArbitraryPrecisionValue('0.05'))
+        .setCouponFrequency(CouponFrequencyProto.SEMIANNUALLY)
+        .setCouponType(CouponTypeProto.FIXED)
+        .setMaturityDate(new LocalDateProto().setYear(2026).setMonth(1).setDay(1))
+        .setIssueDate(new LocalDateProto().setYear(2021).setMonth(1).setDay(1))
+        .setDescription("Dummy bond")
+    );
+}
+
+function dummyEquity() {
+    // Equity has no maturity / issue date in the proto, exercising the
+    // null-return behavior on getIssueDate and the throw-on-missing
+    // behavior on getMaturityDate.
+    return Security.create(new SecurityProto()
+        .setObjectClass('Security').setVersion('0.0.1').setUuid(UUID.random().toUUIDProto())
+        .setSecurityType(SecurityTypeProto.EQUITY_SECURITY)
+        .setAssetClass("Equity")
+        .setIssuerName("Dummy issuer Inc.")
+        .setDescription("Dummy equity")
+    );
+}
+

package/node/wrappers/models/security/security.ts

@@ -29,6 +29,25 @@ class Security {
     }
   }
 
+  /**
+   * Type guard: true iff this Security is a BondSecurity (BOND_SECURITY,
+   * TIPS, or FRN). Use to narrow before calling bond-specific getters:
+   *
+   *   if (sec.isBond()) {
+   *     // sec: BondSecurity here — TS knows about getCouponRate(), etc.
+   *     console.log(sec.getMaturityDate());
+   *   }
+   *
+   * Implemented as a runtime check on the proto's securityType so it
+   * works regardless of how the wrapper was constructed.
+   */
+  isBond(): this is import('./BondSecurity').default {
+    const t = this.proto.getSecurityType();
+    return t === SecurityTypeProto.BOND_SECURITY
+        || t === SecurityTypeProto.TIPS
+        || t === SecurityTypeProto.FRN;
+  }
+
 
   toString(): string {
     return `ID[${this.getID().toString()}], ${this.getSecurityID()}[${this.getIssuerName()}]`;
@@ -57,8 +76,11 @@ class Security {
       case FieldProto.ADJUSTED_TENOR:
         throw new Error('Not implemented yet');
       case FieldProto.MATURITY_DATE:
-        return this.getMaturityDate();
+        // Maturity date is bond-only. Mirror Java's Security.getField:
+        // delegate to BondSecurity, return null for non-bonds.
+        return this.isBond() ? this.getMaturityDate() : null;
       case FieldProto.ISSUE_DATE:
+        // getIssueDate already returns null on non-bonds; just forward.
         return this.getIssueDate();
       default:
         throw new Error(`Field not mapped in Security wrapper: ${field}`);
@@ -109,14 +131,36 @@ class Security {
     return identifier;
   }
 
-  getIssueDate(): LocalDate {
+  /**
+   * Returns the issue date if set, else null. Per-type semantic:
+   *   - Bond / TIPS / FRN: auction date.
+   *   - Equity: IPO listing date (when present in source data).
+   *   - CPI series: first observation date.
+   *   - Cash / FX: typically null.
+   *
+   * Returns null on equities/cash/etc. that don't have an issue date set,
+   * rather than throwing — issue date is optional on the base Security.
+   * For bond-specific code paths, prefer narrowing first via isBond() and
+   * calling BondSecurity.getIssueDate() (which returns LocalDate, not null).
+   */
+  getIssueDate(): LocalDate | null {
     // Prefer oneof bond sub-message if available, fall back to flat fields
     const bond = this.getBondLikeDetails();
     const date = bond ? bond.getIssueDate() : this.proto.getIssueDate();
-    if (!date) throw new Error("Issue date is required");
+    if (!date) return null;
     return new LocalDate(date);
   }
 
+  /**
+   * @deprecated Maturity date is a bond-only concept. On the base Security
+   * this still throws when unset for backwards compatibility. Prefer
+   * narrowing first:
+   *
+   *   if (sec.isBond()) sec.getMaturityDate();   // BondSecurity, returns LocalDate
+   *
+   * In a future major version this method will move to BondSecurity only
+   * and TS will catch the misuse at compile time.
+   */
   getMaturityDate(): LocalDate {
     // Prefer oneof bond sub-message if available, fall back to flat fields
     const bond = this.getBondLikeDetails();

package/node/wrappers/models/security/security_type.d.ts

@@ -0,0 +1,31 @@
+import { SecurityTypeProto } from '../../../fintekkers/models/security/security_type_pb';
+/**
+ * Static helpers around the SecurityType proto enum, mirroring the
+ * Identifier wrapper pattern shipped in v0.1.133 (PR #188).
+ *
+ * Lets TS/JS consumers stop hand-typing literal unions and switch
+ * statements over `'BOND_SECURITY' | 'TIPS' | 'FRN' | ...` — adding a
+ * new variant on the proto side propagates automatically.
+ */
+export declare class SecurityType {
+    /**
+     * Returns the names of all known SecurityTypeProto values, EXCLUDING
+     * the sentinel `UNKNOWN_SECURITY_TYPE`. Drives UI dropdowns / pickers
+     * so a new proto enum variant auto-propagates to consumers without
+     * any UI-side code change.
+     *
+     * Order matches proto declaration order (Object.keys preserves
+     * insertion order on the generated JS enum object).
+     */
+    static getAllTypeNames(): string[];
+    /**
+     * Resolve a proto enum NAME (e.g., "BOND_SECURITY", "EQUITY_SECURITY")
+     * to its numeric SecurityTypeProto value. Throws on unknown name; the
+     * error lists the valid names so typos are fixable without grepping
+     * the proto.
+     *
+     * @param name proto enum key (e.g., "BOND_SECURITY")
+     * @returns the numeric SecurityTypeProto value
+     */
+    static fromName(name: string): SecurityTypeProto;
+}

package/node/wrappers/models/security/security_type.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityType = void 0;
+const security_type_pb_1 = require("../../../fintekkers/models/security/security_type_pb");
+/**
+ * Static helpers around the SecurityType proto enum, mirroring the
+ * Identifier wrapper pattern shipped in v0.1.133 (PR #188).
+ *
+ * Lets TS/JS consumers stop hand-typing literal unions and switch
+ * statements over `'BOND_SECURITY' | 'TIPS' | 'FRN' | ...` — adding a
+ * new variant on the proto side propagates automatically.
+ */
+class SecurityType {
+    /**
+     * Returns the names of all known SecurityTypeProto values, EXCLUDING
+     * the sentinel `UNKNOWN_SECURITY_TYPE`. Drives UI dropdowns / pickers
+     * so a new proto enum variant auto-propagates to consumers without
+     * any UI-side code change.
+     *
+     * Order matches proto declaration order (Object.keys preserves
+     * insertion order on the generated JS enum object).
+     */
+    static getAllTypeNames() {
+        return Object.keys(security_type_pb_1.SecurityTypeProto).filter(k => k !== 'UNKNOWN_SECURITY_TYPE');
+    }
+    /**
+     * Resolve a proto enum NAME (e.g., "BOND_SECURITY", "EQUITY_SECURITY")
+     * to its numeric SecurityTypeProto value. Throws on unknown name; the
+     * error lists the valid names so typos are fixable without grepping
+     * the proto.
+     *
+     * @param name proto enum key (e.g., "BOND_SECURITY")
+     * @returns the numeric SecurityTypeProto value
+     */
+    static fromName(name) {
+        const enumObj = security_type_pb_1.SecurityTypeProto;
+        const enumValue = enumObj[name];
+        if (enumValue === undefined) {
+            throw new Error(`Unknown SecurityType name: '${name}'. Valid names: ${SecurityType.getAllTypeNames().join(', ')}`);
+        }
+        return enumValue;
+    }
+}
+exports.SecurityType = SecurityType;
+//# sourceMappingURL=security_type.js.map

package/node/wrappers/models/security/security_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security_type.js","sourceRoot":"","sources":["security_type.ts"],"names":[],"mappings":";;;AAAA,2FAAyF;AAEzF;;;;;;;GAOG;AACH,MAAa,YAAY;IAErB;;;;;;;;OAQG;IACH,MAAM,CAAC,eAAe;QAClB,OAAO,MAAM,CAAC,IAAI,CAAC,oCAAiB,CAAC,CAAC,MAAM,CACxC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,uBAAuB,CACrC,CAAC;IACN,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAY;QACxB,MAAM,OAAO,GAAG,oCAAsD,CAAC;QACvE,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,SAAS,KAAK,SAAS,EAAE;YACzB,MAAM,IAAI,KAAK,CACX,+BAA+B,IAAI,mBAAmB,YAAY,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpG,CAAC;SACL;QACD,OAAO,SAA8B,CAAC;IAC1C,CAAC;CACJ;AApCD,oCAoCC"}

package/node/wrappers/models/security/security_type.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node/wrappers/models/security/security_type.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const security_type_1 = require("./security_type");
+const security_type_pb_1 = require("../../../fintekkers/models/security/security_type_pb");
+describe('SecurityType.fromName', () => {
+    // Round-trip: every name returned by getAllTypeNames must resolve to
+    // a numeric enum value that maps back to the same name.
+    test.each(security_type_1.SecurityType.getAllTypeNames())('fromName("%s") returns the matching numeric enum value', (name) => {
+        const value = security_type_1.SecurityType.fromName(name);
+        // The proto-generated enum is bidirectionally indexable
+        // (Object.keys / numeric-key lookups both work in google-protobuf JS).
+        const expected = security_type_pb_1.SecurityTypeProto[name];
+        expect(value).toBe(expected);
+    });
+    test('throws on unknown name and lists valid names in the error', () => {
+        let err;
+        try {
+            security_type_1.SecurityType.fromName('NOT_A_REAL_TYPE');
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(err).toBeDefined();
+        expect(err.message).toContain('NOT_A_REAL_TYPE');
+        // Error message should hint with known valid entries.
+        expect(err.message).toContain('BOND_SECURITY');
+        expect(err.message).toContain('EQUITY_SECURITY');
+    });
+    test('accepts UNKNOWN_SECURITY_TYPE — sentinel is a valid enum key', () => {
+        // It's excluded from getAllTypeNames (so it doesn't appear in
+        // dropdowns), but it IS a valid proto enum value, so fromName
+        // accepts it. Pinning the existing behavior — flip if policy
+        // ever tightens.
+        expect(security_type_1.SecurityType.fromName('UNKNOWN_SECURITY_TYPE')).toBe(security_type_pb_1.SecurityTypeProto.UNKNOWN_SECURITY_TYPE);
+    });
+});
+describe('SecurityType.getAllTypeNames', () => {
+    test('returns the expected set in proto-declaration order, excluding UNKNOWN', () => {
+        // Proto-declared order in security_type.proto:
+        //   UNKNOWN_SECURITY_TYPE = 0;  (excluded)
+        //   CASH_SECURITY = 1;
+        //   EQUITY_SECURITY = 2;
+        //   BOND_SECURITY = 3;
+        //   TIPS = 4;
+        //   FRN = 5;
+        //   INDEX_SECURITY = 6;
+        //   FX_SPOT = 7;
+        //   EQUITY_INDEX_SECURITY = 8;
+        expect(security_type_1.SecurityType.getAllTypeNames()).toEqual([
+            'CASH_SECURITY',
+            'EQUITY_SECURITY',
+            'BOND_SECURITY',
+            'TIPS',
+            'FRN',
+            'INDEX_SECURITY',
+            'FX_SPOT',
+            'EQUITY_INDEX_SECURITY',
+        ]);
+    });
+    test('excludes the UNKNOWN_SECURITY_TYPE sentinel', () => {
+        expect(security_type_1.SecurityType.getAllTypeNames()).not.toContain('UNKNOWN_SECURITY_TYPE');
+    });
+});
+//# sourceMappingURL=security_type.test.js.map

package/node/wrappers/models/security/security_type.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security_type.test.js","sourceRoot":"","sources":["security_type.test.ts"],"names":[],"mappings":";;AAAA,mDAA+C;AAC/C,2FAAyF;AAEzF,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACnC,qEAAqE;IACrE,wDAAwD;IACxD,IAAI,CAAC,IAAI,CAAC,4BAAY,CAAC,eAAe,EAAE,CAAC,CACrC,wDAAwD,EACxD,CAAC,IAAY,EAAE,EAAE;QACb,MAAM,KAAK,GAAG,4BAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC1C,wDAAwD;QACxD,uEAAuE;QACvE,MAAM,QAAQ,GAAI,oCAAuD,CAAC,IAAI,CAAC,CAAC;QAChF,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC,CACJ,CAAC;IAEF,IAAI,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,IAAI,GAAsB,CAAC;QAC3B,IAAI;YACA,4BAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;SAC5C;QAAC,OAAO,CAAC,EAAE;YACR,GAAG,GAAG,CAAU,CAAC;SACpB;QACD,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QAClD,sDAAsD;QACtD,MAAM,CAAC,GAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QAChD,MAAM,CAAC,GAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,8DAA8D;QAC9D,8DAA8D;QAC9D,6DAA6D;QAC7D,iBAAiB;QACjB,MAAM,CAAC,4BAAY,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAI,CACvD,oCAAiB,CAAC,qBAAqB,CAC1C,CAAC;IACN,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;IAC1C,IAAI,CAAC,wEAAwE,EAAE,GAAG,EAAE;QAChF,+CAA+C;QAC/C,2CAA2C;QAC3C,uBAAuB;QACvB,yBAAyB;QACzB,uBAAuB;QACvB,cAAc;QACd,aAAa;QACb,wBAAwB;QACxB,iBAAiB;QACjB,+BAA+B;QAC/B,MAAM,CAAC,4BAAY,CAAC,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC;YAC3C,eAAe;YACf,iBAAiB;YACjB,eAAe;YACf,MAAM;YACN,KAAK;YACL,gBAAgB;YAChB,SAAS;YACT,uBAAuB;SAC1B,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,CAAC,4BAAY,CAAC,eAAe,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAAC;IAClF,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/node/wrappers/models/security/security_type.test.ts

@@ -0,0 +1,70 @@
+import { SecurityType } from './security_type';
+import { SecurityTypeProto } from '../../../fintekkers/models/security/security_type_pb';
+
+describe('SecurityType.fromName', () => {
+    // Round-trip: every name returned by getAllTypeNames must resolve to
+    // a numeric enum value that maps back to the same name.
+    test.each(SecurityType.getAllTypeNames())(
+        'fromName("%s") returns the matching numeric enum value',
+        (name: string) => {
+            const value = SecurityType.fromName(name);
+            // The proto-generated enum is bidirectionally indexable
+            // (Object.keys / numeric-key lookups both work in google-protobuf JS).
+            const expected = (SecurityTypeProto as unknown as Record<string, number>)[name];
+            expect(value).toBe(expected);
+        }
+    );
+
+    test('throws on unknown name and lists valid names in the error', () => {
+        let err: Error | undefined;
+        try {
+            SecurityType.fromName('NOT_A_REAL_TYPE');
+        } catch (e) {
+            err = e as Error;
+        }
+        expect(err).toBeDefined();
+        expect(err!.message).toContain('NOT_A_REAL_TYPE');
+        // Error message should hint with known valid entries.
+        expect(err!.message).toContain('BOND_SECURITY');
+        expect(err!.message).toContain('EQUITY_SECURITY');
+    });
+
+    test('accepts UNKNOWN_SECURITY_TYPE — sentinel is a valid enum key', () => {
+        // It's excluded from getAllTypeNames (so it doesn't appear in
+        // dropdowns), but it IS a valid proto enum value, so fromName
+        // accepts it. Pinning the existing behavior — flip if policy
+        // ever tightens.
+        expect(SecurityType.fromName('UNKNOWN_SECURITY_TYPE')).toBe(
+            SecurityTypeProto.UNKNOWN_SECURITY_TYPE
+        );
+    });
+});
+
+describe('SecurityType.getAllTypeNames', () => {
+    test('returns the expected set in proto-declaration order, excluding UNKNOWN', () => {
+        // Proto-declared order in security_type.proto:
+        //   UNKNOWN_SECURITY_TYPE = 0;  (excluded)
+        //   CASH_SECURITY = 1;
+        //   EQUITY_SECURITY = 2;
+        //   BOND_SECURITY = 3;
+        //   TIPS = 4;
+        //   FRN = 5;
+        //   INDEX_SECURITY = 6;
+        //   FX_SPOT = 7;
+        //   EQUITY_INDEX_SECURITY = 8;
+        expect(SecurityType.getAllTypeNames()).toEqual([
+            'CASH_SECURITY',
+            'EQUITY_SECURITY',
+            'BOND_SECURITY',
+            'TIPS',
+            'FRN',
+            'INDEX_SECURITY',
+            'FX_SPOT',
+            'EQUITY_INDEX_SECURITY',
+        ]);
+    });
+
+    test('excludes the UNKNOWN_SECURITY_TYPE sentinel', () => {
+        expect(SecurityType.getAllTypeNames()).not.toContain('UNKNOWN_SECURITY_TYPE');
+    });
+});

package/node/wrappers/models/security/security_type.ts

@@ -0,0 +1,47 @@
+import { SecurityTypeProto } from '../../../fintekkers/models/security/security_type_pb';
+
+/**
+ * Static helpers around the SecurityType proto enum, mirroring the
+ * Identifier wrapper pattern shipped in v0.1.133 (PR #188).
+ *
+ * Lets TS/JS consumers stop hand-typing literal unions and switch
+ * statements over `'BOND_SECURITY' | 'TIPS' | 'FRN' | ...` — adding a
+ * new variant on the proto side propagates automatically.
+ */
+export class SecurityType {
+
+    /**
+     * Returns the names of all known SecurityTypeProto values, EXCLUDING
+     * the sentinel `UNKNOWN_SECURITY_TYPE`. Drives UI dropdowns / pickers
+     * so a new proto enum variant auto-propagates to consumers without
+     * any UI-side code change.
+     *
+     * Order matches proto declaration order (Object.keys preserves
+     * insertion order on the generated JS enum object).
+     */
+    static getAllTypeNames(): string[] {
+        return Object.keys(SecurityTypeProto).filter(
+            k => k !== 'UNKNOWN_SECURITY_TYPE'
+        );
+    }
+
+    /**
+     * Resolve a proto enum NAME (e.g., "BOND_SECURITY", "EQUITY_SECURITY")
+     * to its numeric SecurityTypeProto value. Throws on unknown name; the
+     * error lists the valid names so typos are fixable without grepping
+     * the proto.
+     *
+     * @param name proto enum key (e.g., "BOND_SECURITY")
+     * @returns the numeric SecurityTypeProto value
+     */
+    static fromName(name: string): SecurityTypeProto {
+        const enumObj = SecurityTypeProto as unknown as Record<string, number>;
+        const enumValue = enumObj[name];
+        if (enumValue === undefined) {
+            throw new Error(
+                `Unknown SecurityType name: '${name}'. Valid names: ${SecurityType.getAllTypeNames().join(', ')}`
+            );
+        }
+        return enumValue as SecurityTypeProto;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fintekkers/ledger-models",
   "todo": "Replace the version with build script version number",
-  "version": "0.1.132",
+  "version": "0.1.134",
   "description": "ledger model protos ",
   "authors": [
     "David Doherty",