@holoscript/plugin-insurance 2.0.1 → 2.0.2

package/src/traits/ClaimTrait.ts

@@ -1,23 +1,77 @@
 /** @claim Trait — Insurance claim processing. @trait claim */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type ClaimStatus = 'filed' | 'under_review' | 'approved' | 'denied' | 'paid' | 'appealed' | 'closed';
-export interface ClaimConfig { claimNumber: string; policyNumber: string; dateOfLoss: string; description: string; claimAmount: number; claimantName: string; }
-export interface ClaimState { status: ClaimStatus; approvedAmount: number; adjusterAssigned: string | null; filedAt: number; }
+export type ClaimStatus =
+  | 'filed'
+  | 'under_review'
+  | 'approved'
+  | 'denied'
+  | 'paid'
+  | 'appealed'
+  | 'closed';
+export interface ClaimConfig {
+  claimNumber: string;
+  policyNumber: string;
+  dateOfLoss: string;
+  description: string;
+  claimAmount: number;
+  claimantName: string;
+}
+export interface ClaimState {
+  status: ClaimStatus;
+  approvedAmount: number;
+  adjusterAssigned: string | null;
+  filedAt: number;
+}
 
-const defaultConfig: ClaimConfig = { claimNumber: '', policyNumber: '', dateOfLoss: '', description: '', claimAmount: 0, claimantName: '' };
+const defaultConfig: ClaimConfig = {
+  claimNumber: '',
+  policyNumber: '',
+  dateOfLoss: '',
+  description: '',
+  claimAmount: 0,
+  claimantName: '',
+};
 
 export function createClaimHandler(): TraitHandler<ClaimConfig> {
-  return { name: 'claim', defaultConfig,
-    onAttach(n: HSPlusNode, _c: ClaimConfig, ctx: TraitContext) { n.__claimState = { status: 'filed' as ClaimStatus, approvedAmount: 0, adjusterAssigned: null, filedAt: Date.now() }; ctx.emit?.('claim:filed'); },
-    onDetach(n: HSPlusNode, _c: ClaimConfig, ctx: TraitContext) { delete n.__claimState; ctx.emit?.('claim:removed'); },
+  return {
+    name: 'claim',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: ClaimConfig, ctx: TraitContext) {
+      n.__claimState = {
+        status: 'filed' as ClaimStatus,
+        approvedAmount: 0,
+        adjusterAssigned: null,
+        filedAt: Date.now(),
+      };
+      ctx.emit?.('claim:filed');
+    },
+    onDetach(n: HSPlusNode, _c: ClaimConfig, ctx: TraitContext) {
+      delete n.__claimState;
+      ctx.emit?.('claim:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: ClaimConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__claimState as ClaimState | undefined; if (!s) return;
-      if (e.type === 'claim:assign_adjuster') { s.adjusterAssigned = (e.payload?.adjuster as string) ?? null; s.status = 'under_review'; ctx.emit?.('claim:reviewing', { adjuster: s.adjusterAssigned }); }
-      if (e.type === 'claim:approve') { s.status = 'approved'; s.approvedAmount = (e.payload?.amount as number) ?? c.claimAmount; ctx.emit?.('claim:approved', { amount: s.approvedAmount }); }
-      if (e.type === 'claim:deny') { s.status = 'denied'; ctx.emit?.('claim:denied', { reason: e.payload?.reason }); }
-      if (e.type === 'claim:pay') { s.status = 'paid'; ctx.emit?.('claim:paid', { amount: s.approvedAmount }); }
+      const s = n.__claimState as ClaimState | undefined;
+      if (!s) return;
+      if (e.type === 'claim:assign_adjuster') {
+        s.adjusterAssigned = (e.payload?.adjuster as string) ?? null;
+        s.status = 'under_review';
+        ctx.emit?.('claim:reviewing', { adjuster: s.adjusterAssigned });
+      }
+      if (e.type === 'claim:approve') {
+        s.status = 'approved';
+        s.approvedAmount = (e.payload?.amount as number) ?? c.claimAmount;
+        ctx.emit?.('claim:approved', { amount: s.approvedAmount });
+      }
+      if (e.type === 'claim:deny') {
+        s.status = 'denied';
+        ctx.emit?.('claim:denied', { reason: e.payload?.reason });
+      }
+      if (e.type === 'claim:pay') {
+        s.status = 'paid';
+        ctx.emit?.('claim:paid', { amount: s.approvedAmount });
+      }
     },
   };
 }

package/src/traits/PolicyTrait.ts

@@ -3,20 +3,63 @@ import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types
 
 export type PolicyType = 'life' | 'health' | 'auto' | 'home' | 'commercial' | 'liability' | 'cyber';
 export type PolicyStatus = 'quoted' | 'bound' | 'active' | 'lapsed' | 'cancelled' | 'expired';
-export interface PolicyConfig { policyNumber: string; type: PolicyType; insuredName: string; premium: number; coverageAmount: number; deductible: number; effectiveDate: string; expirationDate: string; }
-export interface PolicyState { status: PolicyStatus; claimCount: number; totalPaidClaims: number; remainingCoverage: number; }
+export interface PolicyConfig {
+  policyNumber: string;
+  type: PolicyType;
+  insuredName: string;
+  premium: number;
+  coverageAmount: number;
+  deductible: number;
+  effectiveDate: string;
+  expirationDate: string;
+}
+export interface PolicyState {
+  status: PolicyStatus;
+  claimCount: number;
+  totalPaidClaims: number;
+  remainingCoverage: number;
+}
 
-const defaultConfig: PolicyConfig = { policyNumber: '', type: 'auto', insuredName: '', premium: 0, coverageAmount: 0, deductible: 0, effectiveDate: '', expirationDate: '' };
+const defaultConfig: PolicyConfig = {
+  policyNumber: '',
+  type: 'auto',
+  insuredName: '',
+  premium: 0,
+  coverageAmount: 0,
+  deductible: 0,
+  effectiveDate: '',
+  expirationDate: '',
+};
 
 export function createPolicyHandler(): TraitHandler<PolicyConfig> {
-  return { name: 'policy', defaultConfig,
-    onAttach(n: HSPlusNode, c: PolicyConfig, ctx: TraitContext) { n.__policyState = { status: 'active' as PolicyStatus, claimCount: 0, totalPaidClaims: 0, remainingCoverage: c.coverageAmount }; ctx.emit?.('policy:bound', { type: c.type, coverage: c.coverageAmount }); },
-    onDetach(n: HSPlusNode, _c: PolicyConfig, ctx: TraitContext) { delete n.__policyState; ctx.emit?.('policy:removed'); },
+  return {
+    name: 'policy',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: PolicyConfig, ctx: TraitContext) {
+      n.__policyState = {
+        status: 'active' as PolicyStatus,
+        claimCount: 0,
+        totalPaidClaims: 0,
+        remainingCoverage: c.coverageAmount,
+      };
+      ctx.emit?.('policy:bound', { type: c.type, coverage: c.coverageAmount });
+    },
+    onDetach(n: HSPlusNode, _c: PolicyConfig, ctx: TraitContext) {
+      delete n.__policyState;
+      ctx.emit?.('policy:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: PolicyConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__policyState as PolicyState | undefined; if (!s) return;
-      if (e.type === 'policy:cancel') { s.status = 'cancelled'; ctx.emit?.('policy:cancelled'); }
-      if (e.type === 'policy:renew') { s.status = 'active'; ctx.emit?.('policy:renewed'); }
+      const s = n.__policyState as PolicyState | undefined;
+      if (!s) return;
+      if (e.type === 'policy:cancel') {
+        s.status = 'cancelled';
+        ctx.emit?.('policy:cancelled');
+      }
+      if (e.type === 'policy:renew') {
+        s.status = 'active';
+        ctx.emit?.('policy:renewed');
+      }
     },
   };
 }

package/src/traits/RiskAssessmentTrait.ts

@@ -1,25 +1,51 @@
 /** @risk_assessment Trait — Actuarial risk scoring. @trait risk_assessment */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface RiskFactor { name: string; weight: number; value: number; maxValue: number; }
-export interface RiskAssessmentConfig { factors: RiskFactor[]; baseRate: number; riskClass: 'preferred' | 'standard' | 'substandard' | 'declined'; maxRiskScore: number; }
+export interface RiskFactor {
+  name: string;
+  weight: number;
+  value: number;
+  maxValue: number;
+}
+export interface RiskAssessmentConfig {
+  factors: RiskFactor[];
+  baseRate: number;
+  riskClass: 'preferred' | 'standard' | 'substandard' | 'declined';
+  maxRiskScore: number;
+}
 
-const defaultConfig: RiskAssessmentConfig = { factors: [], baseRate: 100, riskClass: 'standard', maxRiskScore: 100 };
+const defaultConfig: RiskAssessmentConfig = {
+  factors: [],
+  baseRate: 100,
+  riskClass: 'standard',
+  maxRiskScore: 100,
+};
 
 export function createRiskAssessmentHandler(): TraitHandler<RiskAssessmentConfig> {
-  return { name: 'risk_assessment', defaultConfig,
+  return {
+    name: 'risk_assessment',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: RiskAssessmentConfig, ctx: TraitContext) {
       const score = c.factors.reduce((s, f) => s + (f.value / f.maxValue) * f.weight, 0);
-      n.__riskAssessState = { riskScore: Math.min(c.maxRiskScore, score), adjustedPremium: c.baseRate * (1 + score / 100), isAcceptable: c.riskClass !== 'declined' };
+      n.__riskAssessState = {
+        riskScore: Math.min(c.maxRiskScore, score),
+        adjustedPremium: c.baseRate * (1 + score / 100),
+        isAcceptable: c.riskClass !== 'declined',
+      };
       ctx.emit?.('risk_assessment:scored', { score, riskClass: c.riskClass });
     },
-    onDetach(n: HSPlusNode, _c: RiskAssessmentConfig, ctx: TraitContext) { delete n.__riskAssessState; ctx.emit?.('risk_assessment:removed'); },
+    onDetach(n: HSPlusNode, _c: RiskAssessmentConfig, ctx: TraitContext) {
+      delete n.__riskAssessState;
+      ctx.emit?.('risk_assessment:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: RiskAssessmentConfig, ctx: TraitContext, e: TraitEvent) {
       if (e.type === 'risk_assessment:recalculate') {
-        const s = n.__riskAssessState as Record<string, unknown> | undefined; if (!s) return;
+        const s = n.__riskAssessState as Record<string, unknown> | undefined;
+        if (!s) return;
         const score = c.factors.reduce((sum, f) => sum + (f.value / f.maxValue) * f.weight, 0);
-        s.riskScore = Math.min(c.maxRiskScore, score); s.adjustedPremium = c.baseRate * (1 + score / 100);
+        s.riskScore = Math.min(c.maxRiskScore, score);
+        s.adjustedPremium = c.baseRate * (1 + score / 100);
         ctx.emit?.('risk_assessment:updated', { score, premium: s.adjustedPremium });
       }
     },

package/src/traits/UnderwritingTrait.ts

@@ -2,27 +2,62 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type UnderwritingDecision = 'approve' | 'approve_with_conditions' | 'refer' | 'decline';
-export interface UnderwritingConfig { applicationId: string; riskScore: number; requestedCoverage: number; maxAutoCoverage: number; referralThreshold: number; declineThreshold: number; conditions: string[]; }
-export interface UnderwritingState { decision: UnderwritingDecision | null; reviewedAt: number | null; underwriterId: string | null; }
+export interface UnderwritingConfig {
+  applicationId: string;
+  riskScore: number;
+  requestedCoverage: number;
+  maxAutoCoverage: number;
+  referralThreshold: number;
+  declineThreshold: number;
+  conditions: string[];
+}
+export interface UnderwritingState {
+  decision: UnderwritingDecision | null;
+  reviewedAt: number | null;
+  underwriterId: string | null;
+}
 
-const defaultConfig: UnderwritingConfig = { applicationId: '', riskScore: 0, requestedCoverage: 0, maxAutoCoverage: 500000, referralThreshold: 70, declineThreshold: 90, conditions: [] };
+const defaultConfig: UnderwritingConfig = {
+  applicationId: '',
+  riskScore: 0,
+  requestedCoverage: 0,
+  maxAutoCoverage: 500000,
+  referralThreshold: 70,
+  declineThreshold: 90,
+  conditions: [],
+};
 
 export function createUnderwritingHandler(): TraitHandler<UnderwritingConfig> {
-  return { name: 'underwriting', defaultConfig,
-    onAttach(n: HSPlusNode, _c: UnderwritingConfig, ctx: TraitContext) { n.__uwState = { decision: null, reviewedAt: null, underwriterId: null }; ctx.emit?.('underwriting:submitted'); },
-    onDetach(n: HSPlusNode, _c: UnderwritingConfig, ctx: TraitContext) { delete n.__uwState; ctx.emit?.('underwriting:removed'); },
+  return {
+    name: 'underwriting',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: UnderwritingConfig, ctx: TraitContext) {
+      n.__uwState = { decision: null, reviewedAt: null, underwriterId: null };
+      ctx.emit?.('underwriting:submitted');
+    },
+    onDetach(n: HSPlusNode, _c: UnderwritingConfig, ctx: TraitContext) {
+      delete n.__uwState;
+      ctx.emit?.('underwriting:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: UnderwritingConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__uwState as UnderwritingState | undefined; if (!s) return;
+      const s = n.__uwState as UnderwritingState | undefined;
+      if (!s) return;
       if (e.type === 'underwriting:auto_decide') {
         if (c.riskScore >= c.declineThreshold) s.decision = 'decline';
-        else if (c.riskScore >= c.referralThreshold || c.requestedCoverage > c.maxAutoCoverage) s.decision = 'refer';
+        else if (c.riskScore >= c.referralThreshold || c.requestedCoverage > c.maxAutoCoverage)
+          s.decision = 'refer';
         else if (c.conditions.length > 0) s.decision = 'approve_with_conditions';
         else s.decision = 'approve';
         s.reviewedAt = Date.now();
         ctx.emit?.('underwriting:decided', { decision: s.decision, riskScore: c.riskScore });
       }
-      if (e.type === 'underwriting:manual_decide') { s.decision = (e.payload?.decision as UnderwritingDecision) ?? 'refer'; s.underwriterId = (e.payload?.underwriterId as string) ?? null; s.reviewedAt = Date.now(); ctx.emit?.('underwriting:manual_decision', { decision: s.decision }); }
+      if (e.type === 'underwriting:manual_decide') {
+        s.decision = (e.payload?.decision as UnderwritingDecision) ?? 'refer';
+        s.underwriterId = (e.payload?.underwriterId as string) ?? null;
+        s.reviewedAt = Date.now();
+        ctx.emit?.('underwriting:manual_decision', { decision: s.decision });
+      }
     },
   };
 }

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-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.