insurance.no-claims-discount Unreviewed

export function nextNoClaimsDiscount(scale: readonly NcdLevel[], currentYears: number, claims: number, protection: NcdProtection | null): NcdOutcome

/** One step of an NCD scale. */
export interface NcdLevel {
  /** claim-free years from which this level applies */
  readonly years: number;
  /** discount at this level, 6500 = 65% */
  readonly discountBasisPoints: number;
  /** years held after 1, 2, 3... claims from this level; more claims than listed use the last */
  readonly stepBack: readonly number[];
}

/** Protected NCD: claims up to a limit in a window leave the years untouched. */
export interface NcdProtection {
  /** the most claims the protection allows in its window, e.g. 2 in 5 years */
  readonly claimLimit: number;
  /** claims in the window, this year's included */
  readonly claimsInWindow: number;
}

/** The NCD held at renewal. */
export interface NcdOutcome {
  readonly years: number;
  readonly discountBasisPoints: number;
  /** true when protection kept the years from stepping back */
  readonly protectionApplied: boolean;
}

import { nextNoClaimsDiscount } from "#fune/insurance.no-claims-discount@^1";

import { type NcdLevel, type NcdOutcome, type NcdProtection } from "./insurance_no_claims_discount_types.ts";

function wholeAtLeastZero(value: number, name: string): void {
  if (!Number.isInteger(value) || value < 0) {
    throw new RangeError(`${name} must be a whole number of 0 or more, received ${value}`);
  }
}

function levelFor(scale: readonly NcdLevel[], years: number): NcdLevel {
  let found = scale[0];
  for (const level of scale) if (level.years <= years) found = level;
  return found;
}

/**
 * The no-claims discount held at renewal.
 *
 * A claim-free year earns a year. A year with claims steps back to what the
 * scale says for the level held and the number of claims, unless protected
 * NCD covers them, in which case the years stay where they were (a year with
 * a claim earns nothing). Years keep counting past the top of the scale; the
 * discount is the highest level not above them.
 */
export function nextNoClaimsDiscount(
  scale: readonly NcdLevel[],
  currentYears: number,
  claims: number,
  protection: NcdProtection | null
): NcdOutcome {
  if (scale.length === 0) throw new RangeError("the NCD scale must not be empty");
  if (scale[0].years !== 0) throw new RangeError("the NCD scale must start at 0 years");
  for (let i = 0; i < scale.length; i++) {
    const level = scale[i];
    wholeAtLeastZero(level.years, "years");
    if (i > 0 && level.years <= scale[i - 1].years) {
      throw new RangeError("the NCD scale must be in ascending order of years");
    }
    if (!Number.isInteger(level.discountBasisPoints) || level.discountBasisPoints < 0 || level.discountBasisPoints > 10000) {
      throw new RangeError(`discountBasisPoints must be from 0 to 10000, received ${level.discountBasisPoints}`);
    }
    let previous = level.years;
    for (const back of level.stepBack) {
      wholeAtLeastZero(back, "stepBack");
      if (back > previous) {
        throw new RangeError(`stepBack from ${level.years} years must not rise above the level or the step before it`);
      }
      previous = back;
    }
  }
  wholeAtLeastZero(currentYears, "currentYears");
  wholeAtLeastZero(claims, "claims");

  let years: number;
  let protectionApplied = false;
  if (claims === 0) {
    years = currentYears + 1;
  } else {
    let covered = false;
    if (protection !== null && protection !== undefined) {
      wholeAtLeastZero(protection.claimLimit, "claimLimit");
      wholeAtLeastZero(protection.claimsInWindow, "claimsInWindow");
      if (protection.claimsInWindow < claims) {
        throw new RangeError("claimsInWindow must include this year's claims");
      }
      covered = protection.claimsInWindow <= protection.claimLimit;
    }
    if (covered) {
      years = currentYears;
      protectionApplied = true;
    } else {
      const steps = levelFor(scale, currentYears).stepBack;
      years = steps.length === 0 ? 0 : steps[Math.min(claims, steps.length) - 1];
    }
  }
  return { years, discountBasisPoints: levelFor(scale, years).discountBasisPoints, protectionApplied };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add insurance.no-claims-discount

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./insurance.no-claims-discount-1.0.1-typescript.fune, or fetch it from a terminal with fune pull insurance.no-claims-discount@1.0.1:typescript.

The whole function, every language, is one file too: insurance.no-claims-discount-1.0.1.fune, 40,702 bytes, sha256 27923c7f066fa8f20dfcb109cdee16c333ccada33e48bdf747d60c63e1e3d800. It installs into a project of any language.

// fune: before insurance.no-claims-discount

// fune: after insurance.no-claims-discount

// fune: step insurance.no-claims-discount after <n|label>

More from the author

Every insurer publishes its own scale: the discount at each number of claim-free years, and how far a claim steps you back. So the scale is an argument, not data in this package. Each level says:

- `years`: the claim-free years from which it applies (the scale starts at 0 and rises; gaps are fine: years 6 to 8 on a scale with levels at 5 and 9 get the 5-year discount); - `discountBasisPoints`: its discount; - `stepBack`: the years held after 1, 2, 3... claims in a year from this level. More claims than listed use the last entry, and an empty list means any claim goes back to 0. A step never rises above the level or the step before it.

The vectors use an illustrative scale (0, 30, 40, 50, 60, 65% up to 5 years, 70% at 9; one claim at 5 years steps back to 3), not any insurer's.

## The rules applied

- A claim-free year earns one year. Years keep counting beyond the top of the scale (UK insurers quote "9+ years"), and the discount is that of the highest level not above them. - A year with claims steps back by the level the policyholder held at the start of the year: 12 years with a top level at 9 uses the 9-year steps. - **Protected NCD**: when `claimsInWindow` (this year's claims included) is within `claimLimit` (commonly 2 claims in 5 years), the years stay as they were. The claim year earns no extra year, which is how protection is usually sold: it protects the discount, not the premium. Beyond the limit the normal step-back applies. Some insurers do let a protected claim year earn; add one to `years` if yours does.

Which claims count against NCD (a non-fault claim where costs are fully recovered usually does not) is for the caller to decide before calling. Applying the discount to a premium is `money.apply-rate` or `insurance.rating-factors`.

## Before you rely on this

**Not professional advice.** This capability calculates insurance figures from published rules. It is a software component for developers, not financial advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have an actuary review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified actuary has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

1.0.1 marks it unreviewed. The code and the tests are unchanged.

Files