@jjlmoya/utils-finance 1.45.0 → 1.47.0

package/src/tool/renterInsuranceCoverageGapCalculator/component.astro

@@ -0,0 +1,80 @@
+---
+import type { KnownLocale } from '../../types';
+import { INVENTORY_CATEGORIES, type RenterInsuranceInput } from './logic';
+import { currencyOptions, defaultCurrencyByLocale } from './currency';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+interface Props { locale?: KnownLocale; ui?: RenterInsuranceCoverageGapCalculatorUI; }
+const { ui } = Astro.props;
+const t = ui as RenterInsuranceCoverageGapCalculatorUI;
+const locale = Astro.props.locale ?? 'en';
+const defaultCurrency = defaultCurrencyByLocale[locale] ?? 'USD';
+const defaultSymbol = currencyOptions.find(({ code }) => code === defaultCurrency)?.symbol ?? defaultCurrency;
+const initial: RenterInsuranceInput = {
+  currency: defaultCurrency,
+  policyLimit: 18000,
+  deductible: 250,
+  sampleLoss: 5000,
+  inventory: [
+    { category: 'furniture', value: 7000 },
+    { category: 'electronics', value: 6000 },
+    { category: 'clothing', value: 2500 },
+    { category: 'kitchen', value: 1500 },
+    { category: 'personal', value: 1000 },
+    { category: 'other', value: 1000 },
+  ],
+};
+const config = JSON.stringify({ ui: t, initial, locale, currencies: currencyOptions }).replace(/</g, '\\u003c');
+const categoryLabels: Record<(typeof INVENTORY_CATEGORIES)[number], string> = {
+  furniture: t.labelCategoryFurniture,
+  electronics: t.labelCategoryElectronics,
+  clothing: t.labelCategoryClothing,
+  kitchen: t.labelCategoryKitchen,
+  personal: t.labelCategoryPersonal,
+  other: t.labelCategoryOther,
+};
+---
+
+<div class="ric-tool" data-ric-tool>
+  <form class="ric-card" data-ric-form novalidate>
+    <div class="ric-workspace">
+      <section class="ric-inventory-panel" aria-labelledby="ric-inventory-title">
+        <div class="ric-panel-heading"><span class="ric-eyebrow">01 / {t.labelInventory}</span><h2 id="ric-inventory-title">{t.labelInventory}</h2><p>{t.labelInventoryHint}</p></div>
+        <div class="ric-shelf-scene" data-ric-visual role="img" aria-label={t.labelCoverageLine}>
+          <div class="ric-shelf-top"><span>{t.labelReplacementValue}</span><span data-ric-loss-label>{t.labelLossScenario}</span></div>
+          <div class="ric-shelf-track"><span class="ric-contents-fill" data-ric-contents-fill></span><span class="ric-limit-line" data-ric-limit-line aria-label={t.labelLimitMarker}></span><span class="ric-loss-mark" data-ric-loss-mark aria-hidden="true"></span></div>
+          <div class="ric-shelf-legend"><span><i class="ric-dot ric-dot-contents"></i>{t.labelReplacementValue}</span><span><i class="ric-dot ric-dot-limit"></i>{t.labelCoverageLine}</span></div>
+        </div>
+        <div class="ric-inventory-list">
+          {INVENTORY_CATEGORIES.map((category) => <label class="ric-inventory-row" for={`ric-${category}`}><span>{categoryLabels[category]}</span><span class="ric-money-input"><input id={`ric-${category}`} data-category={category} type="number" min="0" max="1000000000" step="0.01" value={initial.inventory.find((item) => item.category === category)?.value ?? 0} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></span></label>)}
+        </div>
+        <ol class="ric-largest-list" data-ric-largest-list aria-label={t.labelLargestCategories}></ol>
+      </section>
+
+      <section class="ric-policy-panel" aria-labelledby="ric-policy-title">
+        <div class="ric-panel-heading"><span class="ric-eyebrow">02 / {t.labelPolicyBoundary}</span><h2 id="ric-policy-title">{t.labelSetLimit}</h2><p>{t.labelPolicyBoundaryHint}</p></div>
+        <div class="ric-field-stack">
+          <div class="ric-field ric-currency-field"><span class="ric-label" id="ric-currency-label">{t.labelCurrency}</span><div class="ric-select"><button type="button" class="ric-select-trigger" data-ric-currency-trigger aria-expanded="false" aria-haspopup="listbox" aria-labelledby="ric-currency-label"><span class="ric-currency-trigger-main"><strong data-ric-selected-symbol>{defaultSymbol}</strong><span data-ric-selected-code>{defaultCurrency}</span></span><span class="ric-currency-arrow" aria-hidden="true"></span></button><div class="ric-select-menu" data-ric-currency-menu role="listbox" aria-label={t.labelCurrency} hidden>{currencyOptions.map(({ code, symbol, name }) => <button type="button" class="ric-currency-option" data-ric-currency-option data-currency={code} role="option" aria-selected={code === defaultCurrency} aria-label={`${symbol} ${name}`}><strong>{symbol}</strong><span>{code}</span><small>{name}</small></button>)}</div></div><small>{t.labelApproximateRates}</small></div>
+          <div class="ric-field"><label for="ric-policy-limit">{t.labelPolicyLimit}</label><div class="ric-money-input"><input id="ric-policy-limit" data-field="policyLimit" type="number" min="0.01" max="1000000000" step="0.01" value={initial.policyLimit} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelPolicyLimitHelp}</small></div>
+          <div class="ric-field"><label for="ric-deductible">{t.labelDeductible}</label><div class="ric-money-input"><input id="ric-deductible" data-field="deductible" type="number" min="0" max="1000000000" step="0.01" value={initial.deductible} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelDeductibleHelp}</small></div>
+          <div class="ric-field"><label for="ric-sample-loss">{t.labelSampleLoss}</label><div class="ric-money-input"><input id="ric-sample-loss" data-field="sampleLoss" type="number" min="0.01" max="1000000000" step="0.01" value={initial.sampleLoss} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelSampleLossHelp}</small></div>
+        </div>
+        <div class="ric-result-block" aria-live="polite" aria-atomic="true"><span class="ric-eyebrow">03 / {t.labelStatus}</span><strong class="ric-status" data-ric-status>{t.labelStatusReview}</strong><p data-ric-status-text></p><p class="ric-error" data-ric-error hidden>{t.labelInvalidInput}</p><div class="ric-metric-main"><span>{t.labelCoverageGap}</span><strong data-ric-gap>—</strong></div><div class="ric-metric-line"><span>{t.labelTotalContents}</span><b data-ric-total>—</b></div><div class="ric-metric-line"><span>{t.labelCoverageRatio}</span><b data-ric-ratio>—</b></div><div class="ric-metric-line"><span>{t.labelEstimatedPayout}</span><b data-ric-payout>—</b></div><div class="ric-metric-line"><span>{t.labelOutOfPocket}</span><b data-ric-out-of-pocket>—</b></div><p class="ric-result-note">{t.labelIllustrativePayout}</p></div>
+        <div class="ric-actions"><button type="button" class="ric-button ric-button-secondary" data-ric-reset>{t.labelReset}</button><button type="button" class="ric-button ric-button-primary" data-ric-copy>{t.labelCopy}</button><span data-ric-copy-status role="status" aria-live="polite"></span></div>
+      </section>
+    </div>
+    <p class="ric-privacy">{t.labelPrivacyNote}</p><details class="ric-method"><summary>{t.labelMethodTitle}</summary><p>{t.labelMethodText}</p></details>
+  </form>
+</div>
+
+<script is:inline type="application/json" data-ric-config set:html={config}></script>
+<script>
+  import { mountRenterInsuranceTool } from './controller';
+  const configElement = document.querySelector<HTMLScriptElement>('[data-ric-config]');
+  const root = document.querySelector<HTMLElement>('[data-ric-tool]');
+  if (root && configElement?.textContent) mountRenterInsuranceTool(root, JSON.parse(configElement.textContent));
+</script>
+
+<style>
+  @import './renter-insurance-coverage-gap-calculator.css';
+</style>

package/src/tool/renterInsuranceCoverageGapCalculator/controller.ts

@@ -0,0 +1,102 @@
+import { calculateRenterInsuranceCoverageGap, validateRenterInsuranceInput, type RenterInsuranceInput } from './logic';
+import { convertRenterInsuranceCurrency, isRenterInsuranceCurrencyCode, type RenterInsuranceCurrencyCode } from './currency';
+import { clearRenterInsuranceResult, formatMoney, renderRenterInsuranceResult, type ViewConfig } from './dom-views';
+import { readSavedRenterInsuranceInput, saveRenterInsuranceInput } from './storage';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+interface ControllerConfig {
+  initial: RenterInsuranceInput;
+  locale: string;
+  ui: RenterInsuranceCoverageGapCalculatorUI;
+}
+
+const getNumber = (form: HTMLFormElement, field: string): number => Number(form.querySelector<HTMLInputElement>(`[data-field="${field}"]`)?.value ?? Number.NaN);
+
+const readInput = (form: HTMLFormElement, currency: string): RenterInsuranceInput => ({
+  currency,
+  policyLimit: getNumber(form, 'policyLimit'),
+  deductible: getNumber(form, 'deductible'),
+  sampleLoss: getNumber(form, 'sampleLoss'),
+  inventory: Array.from(form.querySelectorAll<HTMLInputElement>('[data-category]')).map((input) => ({ category: input.dataset.category as RenterInsuranceInput['inventory'][number]['category'], value: Number(input.value) })),
+});
+
+const setFieldValues = (form: HTMLFormElement, input: RenterInsuranceInput): void => {
+  ['policyLimit', 'deductible', 'sampleLoss'].forEach((field) => {
+    const element = form.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+    if (element) element.value = String(input[field as 'policyLimit' | 'deductible' | 'sampleLoss']);
+  });
+  input.inventory.forEach((item) => {
+    const element = form.querySelector<HTMLInputElement>(`[data-category="${item.category}"]`);
+    if (element) element.value = String(item.value);
+  });
+};
+
+const updateFieldErrors = (root: HTMLElement, form: HTMLFormElement, input: RenterInsuranceInput): boolean => {
+  const errors = validateRenterInsuranceInput(input);
+  form.querySelectorAll<HTMLInputElement>('[data-field], [data-category]').forEach((field) => field.setAttribute('aria-invalid', 'false'));
+  Object.keys(errors).forEach((key) => form.querySelector<HTMLInputElement>(`[data-field="${key}"]`)?.setAttribute('aria-invalid', 'true'));
+  const summary = root.querySelector<HTMLElement>('[data-ric-error]');
+  if (summary) summary.hidden = Object.keys(errors).length === 0;
+  if (errors.inventory) form.querySelectorAll<HTMLInputElement>('[data-category]').forEach((field) => field.setAttribute('aria-invalid', 'true'));
+  return Object.keys(errors).length > 0;
+};
+
+const setCurrency = (root: HTMLElement, currency: RenterInsuranceCurrencyCode): void => {
+  const selectedOption = root.querySelector<HTMLButtonElement>(`[data-ric-currency-option][data-currency="${currency}"]`);
+  const symbol = selectedOption?.querySelector('strong')?.textContent ?? currency;
+  root.querySelectorAll<HTMLElement>('[data-ric-unit]').forEach((unit) => { unit.textContent = symbol; });
+  root.querySelectorAll<HTMLButtonElement>('[data-ric-currency-option]').forEach((option) => option.setAttribute('aria-selected', String(option.dataset.currency === currency)));
+  const selectedCode = root.querySelector<HTMLElement>('[data-ric-selected-code]');
+  if (selectedCode) selectedCode.textContent = currency;
+  const selectedSymbol = root.querySelector<HTMLElement>('[data-ric-selected-symbol]');
+  if (selectedSymbol) selectedSymbol.textContent = symbol;
+};
+
+const mountCurrencyMenu = (root: HTMLElement, onSelect: (currency: RenterInsuranceCurrencyCode) => void): void => {
+  const trigger = root.querySelector<HTMLButtonElement>('[data-ric-currency-trigger]');
+  const menu = root.querySelector<HTMLElement>('[data-ric-currency-menu]');
+  const close = (): void => { if (menu && trigger) { menu.hidden = true; trigger.setAttribute('aria-expanded', 'false'); } };
+  trigger?.addEventListener('click', () => { if (menu) { menu.hidden = !menu.hidden; trigger.setAttribute('aria-expanded', String(!menu.hidden)); } });
+  root.querySelectorAll<HTMLButtonElement>('[data-ric-currency-option]').forEach((option) => option.addEventListener('click', () => { const nextCurrency = option.dataset.currency; if (nextCurrency && isRenterInsuranceCurrencyCode(nextCurrency)) onSelect(nextCurrency); close(); }));
+  document.addEventListener('click', (event) => { if (!root.contains(event.target as Node)) close(); });
+};
+
+const mountCopyAction = (root: HTMLElement, form: HTMLFormElement, config: ControllerConfig, getCurrency: () => RenterInsuranceCurrencyCode): void => {
+  form.querySelector('[data-ric-copy]')?.addEventListener('click', () => {
+    const result = calculateRenterInsuranceCoverageGap(readInput(form, getCurrency()));
+    if (!result) return;
+    const summary = `${config.ui.labelCoverageGap}: ${formatMoney(config.locale, result.currency, result.coverageGap)}. ${config.ui.labelCoverageRatio}: ${Math.round(result.coverageRatio * 100)}%. ${config.ui.labelLargestCategories}: ${result.largestCategories.map((item) => item.category).join(', ')}.`;
+    navigator.clipboard?.writeText(summary).then(() => { const status = root.querySelector<HTMLElement>('[data-ric-copy-status]'); if (status) status.textContent = config.ui.labelCopied; }).catch(() => { const status = root.querySelector<HTMLElement>('[data-ric-copy-status]'); if (status) status.textContent = config.ui.labelCopyFailed; });
+  });
+};
+
+export function mountRenterInsuranceTool(root: HTMLElement, config: ControllerConfig): void {
+  const form = root.querySelector<HTMLFormElement>('[data-ric-form]');
+  if (!form) return;
+  const saved = readSavedRenterInsuranceInput(config.initial);
+  let currency: RenterInsuranceCurrencyCode = isRenterInsuranceCurrencyCode(saved.currency) ? saved.currency : config.initial.currency as RenterInsuranceCurrencyCode;
+  setFieldValues(form, saved);
+  const viewConfig: ViewConfig = { root, locale: config.locale, ui: config.ui };
+  const update = (): void => {
+    const input = readInput(form, currency);
+    if (updateFieldErrors(root, form, input)) { clearRenterInsuranceResult(root, config.ui); return; }
+    const result = calculateRenterInsuranceCoverageGap(input);
+    if (!result) return;
+    saveRenterInsuranceInput(input);
+    renderRenterInsuranceResult(viewConfig, result);
+  };
+  const reset = (): void => { currency = config.initial.currency as RenterInsuranceCurrencyCode; setFieldValues(form, config.initial); setCurrency(root, currency); update(); };
+  form.querySelectorAll<HTMLInputElement>('[data-field], [data-category]').forEach((field) => field.addEventListener('input', update));
+  form.querySelector('[data-ric-reset]')?.addEventListener('click', reset);
+  mountCopyAction(root, form, config, () => currency);
+  mountCurrencyMenu(root, (nextCurrency) => {
+    if (nextCurrency === currency) return;
+    const moneyFields = [...Array.from(form.querySelectorAll<HTMLInputElement>('[data-field]')), ...Array.from(form.querySelectorAll<HTMLInputElement>('[data-category]'))];
+    moneyFields.forEach((field) => { const value = Number(field.value); if (Number.isFinite(value)) field.value = String(convertRenterInsuranceCurrency(value, currency, nextCurrency)); });
+    currency = nextCurrency;
+    setCurrency(root, currency);
+    update();
+  });
+  setCurrency(root, currency);
+  update();
+}

package/src/tool/renterInsuranceCoverageGapCalculator/currency.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { convertRenterInsuranceCurrency, currencyOptions, defaultCurrencyByLocale } from './currency';
+
+describe('renter insurance currency support', () => {
+  it('offers the international currency set used by insurance tools', () => {
+    expect(currencyOptions.map(({ code }) => code)).toEqual(['AUD', 'BRL', 'CAD', 'CHF', 'CNY', 'CZK', 'DKK', 'EUR', 'GBP', 'IDR', 'INR', 'JPY', 'KRW', 'MXN', 'NOK', 'PLN', 'RUB', 'SEK', 'TRY', 'USD']);
+  });
+
+  it('selects a useful default for each supported locale family', () => {
+    expect(defaultCurrencyByLocale).toMatchObject({ en: 'USD', es: 'EUR', ja: 'JPY', zh: 'CNY' });
+  });
+
+  it('converts monetary inputs with reversible planning factors', () => {
+    expect(convertRenterInsuranceCurrency(100, 'EUR', 'USD')).toBe(108.7);
+    expect(convertRenterInsuranceCurrency(108.7, 'USD', 'EUR')).toBe(100);
+  });
+});

package/src/tool/renterInsuranceCoverageGapCalculator/currency.ts

@@ -0,0 +1,69 @@
+export const currencyOptions = [
+  { code: 'AUD', symbol: 'A$', name: 'Australian dollar' },
+  { code: 'BRL', symbol: 'R$', name: 'Brazilian real' },
+  { code: 'CAD', symbol: 'C$', name: 'Canadian dollar' },
+  { code: 'CHF', symbol: 'CHF', name: 'Swiss franc' },
+  { code: 'CNY', symbol: '¥', name: 'Chinese yuan' },
+  { code: 'CZK', symbol: 'Kč', name: 'Czech koruna' },
+  { code: 'DKK', symbol: 'kr', name: 'Danish krone' },
+  { code: 'EUR', symbol: '€', name: 'Euro' },
+  { code: 'GBP', symbol: '£', name: 'British pound' },
+  { code: 'IDR', symbol: 'Rp', name: 'Indonesian rupiah' },
+  { code: 'INR', symbol: '₹', name: 'Indian rupee' },
+  { code: 'JPY', symbol: '¥', name: 'Japanese yen' },
+  { code: 'KRW', symbol: '₩', name: 'South Korean won' },
+  { code: 'MXN', symbol: 'MX$', name: 'Mexican peso' },
+  { code: 'NOK', symbol: 'kr', name: 'Norwegian krone' },
+  { code: 'PLN', symbol: 'zł', name: 'Polish złoty' },
+  { code: 'RUB', symbol: '₽', name: 'Russian ruble' },
+  { code: 'SEK', symbol: 'kr', name: 'Swedish krona' },
+  { code: 'TRY', symbol: '₺', name: 'Turkish lira' },
+  { code: 'USD', symbol: '$', name: 'US dollar' },
+] as const;
+
+export type RenterInsuranceCurrencyCode = (typeof currencyOptions)[number]['code'];
+
+export const defaultCurrencyByLocale: Record<string, RenterInsuranceCurrencyCode> = {
+  de: 'EUR',
+  en: 'USD',
+  es: 'EUR',
+  fr: 'EUR',
+  id: 'IDR',
+  it: 'EUR',
+  ja: 'JPY',
+  ko: 'KRW',
+  nl: 'EUR',
+  pl: 'PLN',
+  pt: 'EUR',
+  ru: 'RUB',
+  sv: 'SEK',
+  tr: 'TRY',
+  zh: 'CNY',
+};
+
+const approximateUsdFactors: Record<RenterInsuranceCurrencyCode, number> = {
+  AUD: 1.52,
+  BRL: 5.1,
+  CAD: 1.38,
+  CHF: 0.88,
+  CNY: 7.2,
+  CZK: 23,
+  DKK: 6.85,
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  IDR: 16000,
+  INR: 84,
+  JPY: 150,
+  KRW: 1380,
+  MXN: 18,
+  NOK: 10.7,
+  PLN: 3.95,
+  RUB: 90,
+  SEK: 10.5,
+  TRY: 34,
+};
+
+export const isRenterInsuranceCurrencyCode = (value: string): value is RenterInsuranceCurrencyCode => currencyOptions.some(({ code }) => code === value);
+
+export const convertRenterInsuranceCurrency = (amount: number, from: RenterInsuranceCurrencyCode, to: RenterInsuranceCurrencyCode): number => Number((amount * approximateUsdFactors[to] / approximateUsdFactors[from]).toFixed(2));

package/src/tool/renterInsuranceCoverageGapCalculator/dom-views.ts

@@ -0,0 +1,68 @@
+import type { CoverageCategoryResult, RenterInsuranceResult } from './logic';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+import { evaluateCoverage } from './evaluator';
+
+export interface ViewConfig {
+  root: HTMLElement;
+  locale: string;
+  ui: RenterInsuranceCoverageGapCalculatorUI;
+}
+
+const setText = (root: HTMLElement, selector: string, value: string): void => {
+  const element = root.querySelector<HTMLElement>(selector);
+  if (element) element.textContent = value;
+};
+
+const formatMoney = (locale: string, currency: string, value: number): string => new Intl.NumberFormat(locale, {
+  style: 'currency',
+  currency,
+  maximumFractionDigits: 2,
+}).format(value);
+
+const renderCategoryList = (root: HTMLElement, categories: CoverageCategoryResult[], locale: string, currency: string): void => {
+  const list = root.querySelector<HTMLOListElement>('[data-ric-largest-list]');
+  if (!list) return;
+  list.replaceChildren(...categories.map((category) => {
+    const item = document.createElement('li');
+    item.textContent = `${category.category}: ${formatMoney(locale, currency, category.value)}`;
+    return item;
+  }));
+};
+
+const renderShelf = (root: HTMLElement, result: RenterInsuranceResult): void => {
+  const total = Math.max(result.totalContents, 1);
+  const contentWidth = Math.min(100, result.totalContents / total * 100);
+  const limitWidth = Math.min(100, result.policyLimit / total * 100);
+  root.querySelector<HTMLElement>('[data-ric-contents-fill]')?.style.setProperty('width', `${contentWidth}%`);
+  root.querySelector<HTMLElement>('[data-ric-limit-line]')?.style.setProperty('left', `${limitWidth}%`);
+  root.querySelector<HTMLElement>('[data-ric-loss-mark]')?.style.setProperty('left', `${Math.min(100, result.sampleLoss / total * 100)}%`);
+};
+
+export function renderRenterInsuranceResult(config: ViewConfig, result: RenterInsuranceResult): void {
+  const { root, locale, ui } = config;
+  const evaluation = evaluateCoverage(result, ui);
+  root.dataset.status = evaluation.status;
+  setText(root, '[data-ric-status]', evaluation.label);
+  setText(root, '[data-ric-status-text]', evaluation.text);
+  setText(root, '[data-ric-total]', formatMoney(locale, result.currency, result.totalContents));
+  setText(root, '[data-ric-gap]', formatMoney(locale, result.currency, result.coverageGap));
+  setText(root, '[data-ric-ratio]', `${new Intl.NumberFormat(locale, { maximumFractionDigits: 1 }).format(result.coverageRatio * 100)}%`);
+  setText(root, '[data-ric-payout]', formatMoney(locale, result.currency, result.estimatedPayout));
+  setText(root, '[data-ric-out-of-pocket]', formatMoney(locale, result.currency, result.estimatedOutOfPocket));
+  setText(root, '[data-ric-loss-label]', `${ui.labelLossScenario}: ${formatMoney(locale, result.currency, result.sampleLoss)}`);
+  renderCategoryList(root, result.largestCategories, locale, result.currency);
+  renderShelf(root, result);
+}
+
+export function clearRenterInsuranceResult(root: HTMLElement, ui: RenterInsuranceCoverageGapCalculatorUI): void {
+  root.dataset.status = 'invalid';
+  ['total', 'gap', 'ratio', 'payout', 'out-of-pocket'].forEach((key) => setText(root, `[data-ric-${key}]`, '—'));
+  setText(root, '[data-ric-status]', ui.labelInvalidInput);
+  setText(root, '[data-ric-status-text]', '');
+  root.querySelector<HTMLElement>('[data-ric-contents-fill]')?.style.setProperty('width', '0%');
+  root.querySelector<HTMLElement>('[data-ric-limit-line]')?.style.setProperty('left', '0%');
+  root.querySelector<HTMLElement>('[data-ric-loss-mark]')?.style.setProperty('left', '0%');
+  root.querySelector('[data-ric-largest-list]')?.replaceChildren();
+}
+
+export { formatMoney };

package/src/tool/renterInsuranceCoverageGapCalculator/entry.ts

@@ -0,0 +1,28 @@
+import type { FinanceToolEntry, ToolLocaleContent } from '../../types';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+export type RenterInsuranceCoverageGapCalculatorLocaleContent = ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI>;
+
+export const renterInsuranceCoverageGapCalculator: FinanceToolEntry<RenterInsuranceCoverageGapCalculatorUI> = {
+  id: 'renter-insurance-coverage-gap-calculator',
+  icons: { bg: 'mdi:home-alert', fg: 'mdi:shield-home' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};
+
+export { bibliography } from './bibliography';

package/src/tool/renterInsuranceCoverageGapCalculator/evaluator.ts

@@ -0,0 +1,17 @@
+import type { CoverageStatus, RenterInsuranceResult } from './logic';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+export interface CoverageEvaluation {
+  status: CoverageStatus;
+  label: string;
+  text: string;
+}
+
+export function evaluateCoverage(result: RenterInsuranceResult, ui: RenterInsuranceCoverageGapCalculatorUI): CoverageEvaluation {
+  const content: Record<CoverageStatus, { label: string; text: string }> = {
+    safe: { label: ui.labelStatusSafe, text: ui.labelStatusSafeText },
+    review: { label: ui.labelStatusReview, text: ui.labelStatusReviewText },
+    exposed: { label: ui.labelStatusExposed, text: ui.labelStatusExposedText },
+  };
+  return { status: result.status, ...content[result.status] };
+}

package/src/tool/renterInsuranceCoverageGapCalculator/i18n/de.ts

@@ -0,0 +1,40 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { RenterInsuranceCoverageGapCalculatorUI } from '../ui';
+
+export const ui: RenterInsuranceCoverageGapCalculatorUI = {
+  labelPolicyLimit: 'Deckungssumme Hausrat', labelDeductible: 'Selbstbeteiligung', labelSampleLoss: 'Beispielschaden', labelCurrency: 'Währung', labelApproximateRates: 'Die Umrechnung nutzt ungefähre Planungsfaktoren und keine Live-Wechselkurse.', labelPolicyBoundary: 'Versicherungsgrenze', labelSetLimit: 'Grenze festlegen', labelPolicyBoundaryHint: 'Übernimm die Hausratwerte aus deiner Police und prüfe anschließend einen möglichen Schaden.', labelInventory: 'Ersatzwert-Inventar', labelInventoryHint: 'Schätze je Kategorie, was der komplette Ersatz heute kosten würde.', labelPolicyLimitHelp: 'Nutze die Hausratdeckung aus der Police, nicht die Gebäudesumme.', labelDeductibleHelp: 'Trage die Selbstbeteiligung für einen Hausratschaden ein.', labelSampleLossHelp: 'Dient nur zur Darstellung eines beispielhaften Schadenfalls nach der Lücke.', labelTotalContents: 'Geschätzter Hausratwert', labelCoverageGap: 'Mögliche Deckungslücke', labelCoverageRatio: 'Geschätzter Deckungsgrad', labelEstimatedPayout: 'Beispielauszahlung', labelOutOfPocket: 'Beispielhafte Eigenzahlung', labelStatus: 'Deckungseinschätzung', labelStatusSafe: 'Grenze deckt Inventar', labelStatusReview: 'Kleine Lücke prüfen', labelStatusExposed: 'Hausrat ist unterversichert', labelStatusSafeText: 'Die eingetragene Hausratgrenze erreicht mindestens den Ersatzwert. Prüfe Sonderlimits für einzelne Gegenstände zusätzlich.', labelStatusReviewText: 'Die Grenze liegt nahe am Inventarwert, aber eine kleine Lücke bleibt. Prüfe teure Gegenstände und neue Anschaffungen.', labelStatusExposedText: 'Die Grenze liegt unter dem Inventarwert. Prüfe die Police, bevor du dich bei einem Totalschaden darauf verlässt.', labelLargestCategories: 'Größte Inventarkategorien', labelCoverageLine: 'Deckungssumme', labelReplacementValue: 'Ersatzwert', labelLimitMarker: 'Markierung der Grenze', labelLossScenario: 'Schadenszenario', labelIllustrativePayout: 'Nur ein Beispiel: Eine Unterversicherungsregel muss auf deine Police nicht zutreffen.', labelReset: 'Beispiel zurücksetzen', labelCopy: 'Zusammenfassung kopieren', labelCopied: 'Zusammenfassung kopiert', labelCopyFailed: 'Ergebnis manuell aus dem Feld kopieren', labelInvalidInput: 'Prüfe den markierten Wert', labelMethodTitle: 'So funktioniert die Schätzung', labelMethodText: 'Das Tool addiert deine Kategoriewerte und vergleicht sie mit der Hausratdeckung. Die Lücke ist die positive Differenz. Die Beispielauszahlung wendet den Deckungsgrad auf den Schaden an und zieht die Selbstbeteiligung ab. Das ist ein Planungsmodell und keine Vorhersage einer Regulierung. Deine Police kann Einzelgrenzen, Neuwertregeln, Ausschlüsse, Erstes-Risiko-Deckung oder eine andere Behandlung von Unterversicherung vorsehen.', labelPrivacyNote: 'Dein Inventar bleibt in diesem Browser. Konto, Upload und Serverberechnung sind nicht erforderlich.', labelAmountPlaceholder: '0,00', labelCategoryFurniture: 'Möbel und Dekoration', labelCategoryElectronics: 'Elektronik', labelCategoryClothing: 'Kleidung und Schuhe', labelCategoryKitchen: 'Küche und Geräte', labelCategoryPersonal: 'Persönliche Gegenstände', labelCategoryOther: 'Sonstiger Hausrat',
+};
+
+const slug = 'mieterversicherung-unterversicherung-hausrat-rechner';
+const title = 'Rechner für die Deckungslücke bei der Hausratversicherung';
+const description = 'Prüfe, ob die Hausratdeckung deiner Mieterversicherung den Ersatzwert deiner Sachen erreicht. Vergleiche Inventar, Versicherungssumme, Selbstbeteiligung und einen Beispielschaden direkt im Browser.';
+const faq = [
+  { question: 'Was misst dieser Rechner für die Hausratversicherung?', answer: 'Er addiert die von dir eingetragenen Ersatzwerte und vergleicht die Summe mit der Hausratdeckung. Die Differenz zeigt als Planungsschätzung, welcher Betrag möglicherweise außerhalb der Grenze liegt.' },
+  { question: 'Welchen Wert soll ich für mein Inventar eintragen?', answer: 'Nutze realistische aktuelle Ersatzkosten für Möbel, Elektronik, Kleidung, Geräte und persönliche Gegenstände. Prüfe, ob deine Police den Neuwert oder eine andere Bewertungsgrundlage verlangt.' },
+  { question: 'Beweist das Ergebnis eine Unterversicherung?', answer: 'Nein. Das Ergebnis hängt von deinem Inventar, dem Vertrag und deinen Bewertungsannahmen ab. Einzelgrenzen, Ausschlüsse, besondere Vereinbarungen und Unterversicherungsklauseln können einen Schaden anders behandeln.' },
+  { question: 'Warum zeigt der Rechner eine Beispielauszahlung?', answer: 'Sie macht sichtbar, was ein einfaches proportionales Modell für den eingetragenen Schaden nach Abzug der Selbstbeteiligung ergeben würde. Sie sagt nicht voraus, was der Versicherer tatsächlich zahlt.' },
+  { question: 'Soll ich Einbauten und Ausstattung des Vermieters einrechnen?', answer: 'Nur Gegenstände, die laut Police zu deiner Hausratdeckung gehören. Haftpflicht, Gebäude, Einbauten und Hausrat können getrennte Bereiche sein und sollten nicht künstlich zusammengezählt werden.' },
+];
+const howTo = [
+  { name: 'Ersatzwert-Inventar erstellen', text: 'Gehe durch alle Räume und trage ein, was ein Ersatz des Hausrats heute kosten würde. Ordne die Werte den sechs Kategorien zu, damit die größten Posten sichtbar bleiben.' },
+  { name: 'Hausratgrenze eintragen', text: 'Übernimm die Versicherungssumme aus dem Versicherungsschein oder Angebot. Verwende nicht die Gebäude- oder Haftpflichtsumme.' },
+  { name: 'Selbstbeteiligung und Schaden ergänzen', text: 'Trage die Selbstbeteiligung und einen Beispielschaden ein, um eine beispielhafte Eigenzahlung zu sehen.' },
+  { name: 'Entscheidungsgrenze prüfen', text: 'Bei einer Lücke solltest du teure Gegenstände, Einzelgrenzen, Wertsachen und neue Anschaffungen mit Versicherer oder Makler prüfen.' },
+];
+export const content: ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI> = { slug, title, description, ui, seo: [
+  { type: 'title', text: 'Vergleiche die Grenze mit dem Wert deines Hausrats', level: 2 },
+  { type: 'paragraph', html: '<p>Eine Hausratversicherung wird leicht zu niedrig angesetzt, wenn die Summe nur grob gewählt statt Raum für Raum ermittelt wird. Dieser Rechner macht deine eigenen Ersatzschätzungen als Deckungsgrenze sichtbar, bevor du einen Schaden melden musst.</p>' },
+  { type: 'title', text: 'Das solltest du vor der Berechnung sammeln', level: 2 },
+  { type: 'list', items: ['Ersatzwerte für Möbel, Elektronik, Kleidung, Geräte und persönliche Gegenstände.', 'Die Hausratdeckung aus dem Versicherungsschein, getrennt von Gebäude und Haftpflicht.', 'Die Selbstbeteiligung für einen Hausratschaden.', 'Einen realistischen Beispielschaden, wenn du die Beispielauszahlung prüfen möchtest.'] },
+  { type: 'title', text: 'So liest du die Deckungslücke', level: 2 },
+  { type: 'paragraph', html: '<p>Die Lücke ist der Inventarwert oberhalb der Grenze. Null bedeutet, dass beide Summen unter deinen Annahmen übereinstimmen; es bestätigt nicht die Deckung jedes einzelnen Gegenstands. Eine positive Lücke ist ein Anlass, Bewertungsgrundlage, Einzelgrenzen, Ausschlüsse und Unterversicherungsklauseln zu prüfen.</p>' },
+  { type: 'table', headers: ['Signal', 'Aussage', 'Nächster sinnvoller Schritt'], rows: [['Grenze deckt Inventar', 'Die Grenze erreicht mindestens die eingetragene Ersatzsumme.', 'Wertsachen, Einzelgrenzen und Ausschlüsse prüfen.'], ['Kleine Lücke prüfen', 'Die Grenze liegt nahe am Wert, doch neue Käufe oder Rundungen können zählen.', 'Die größten Kategorien neu bewerten und die Summe anpassen.'], ['Hausrat ist unterversichert', 'Die Grenze liegt deutlich unter dem Ersatzwert.', 'Neues Angebot anfordern oder die Unterversicherungsregel klären.']] },
+  { type: 'title', text: 'Grenzen der Schätzung', level: 2 },
+  { type: 'paragraph', html: '<p>Das Tool liest keine Police, entscheidet nicht über die Deckung und berechnet keine verbindliche Entschädigung. Das Schadenbeispiel nutzt ein einfaches proportionales Modell und zieht die Selbstbeteiligung ab. Verträge können andere Klauseln, Wertansätze, Ausschlüsse oder Erstes-Risiko-Regeln enthalten.</p>' },
+  { type: 'tip', title: 'Tipp zur Dokumentation', html: '<p>Bewahre Rechnungen, Fotos und ein datiertes Inventar für wertvolle Sachen auf. Der Financial Ombudsman Service erläutert, warum fehlende Ersatzwertberechnung zu Unterversicherung führen kann; das spanische Versicherungsvertragsgesetz beschreibt die Versicherungssumme als maximale Entschädigung und eine proportionale Regel bei Unterversicherung, sofern die Police nichts anderes bestimmt.</p>' },
+], faq, bibliography, howTo, schemas: [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) },
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+] };

package/src/tool/renterInsuranceCoverageGapCalculator/i18n/en.ts

@@ -0,0 +1,98 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { RenterInsuranceCoverageGapCalculatorUI } from '../ui';
+
+export const ui: RenterInsuranceCoverageGapCalculatorUI = {
+  labelPolicyLimit: 'Contents coverage limit',
+  labelDeductible: 'Deductible',
+  labelSampleLoss: 'Illustrative loss scenario',
+  labelCurrency: 'Currency',
+  labelApproximateRates: 'Currency changes use approximate planning factors, not live exchange rates.',
+  labelPolicyBoundary: 'Policy boundary',
+  labelSetLimit: 'Set the limit',
+  labelPolicyBoundaryHint: 'Use the contents figures from your policy, then test one possible loss.',
+  labelInventory: 'Replacement inventory',
+  labelInventoryHint: 'Estimate what it would cost to replace everything today, by category.',
+  labelPolicyLimitHelp: 'Use the contents limit shown in your policy, not the building limit.',
+  labelDeductibleHelp: 'Enter the excess or deductible that applies to a contents claim.',
+  labelSampleLossHelp: 'Used only to show an illustrative claim scenario after the gap is found.',
+  labelTotalContents: 'Estimated contents value',
+  labelCoverageGap: 'Potential coverage gap',
+  labelCoverageRatio: 'Estimated cover ratio',
+  labelEstimatedPayout: 'Illustrative payout',
+  labelOutOfPocket: 'Illustrative out of pocket',
+  labelStatus: 'Coverage reading',
+  labelStatusSafe: 'Limit reaches the inventory',
+  labelStatusReview: 'Small gap to review',
+  labelStatusExposed: 'Contents are underinsured',
+  labelStatusSafeText: 'Your entered contents limit is at least as high as the replacement inventory. Check special item limits separately.',
+  labelStatusReviewText: 'The limit is close to the inventory estimate, but a small gap remains. Recheck expensive items and recent purchases.',
+  labelStatusExposedText: 'The limit is below the inventory estimate. Review the policy before relying on it for a total contents loss.',
+  labelLargestCategories: 'Largest inventory categories',
+  labelCoverageLine: 'Policy limit',
+  labelReplacementValue: 'Replacement value',
+  labelLimitMarker: 'Limit marker',
+  labelLossScenario: 'Loss scenario',
+  labelIllustrativePayout: 'Illustrative only: a proportional clause may not apply to your policy.',
+  labelReset: 'Reset example',
+  labelCopy: 'Copy summary',
+  labelCopied: 'Summary copied',
+  labelCopyFailed: 'Copy it manually from the result',
+  labelInvalidInput: 'Check the highlighted value',
+  labelMethodTitle: 'How this estimate works',
+  labelMethodText: 'The tool adds your category estimates and compares them with the contents limit. The gap is the positive difference between those values. The illustrative payout applies the cover ratio to the loss scenario, then subtracts the deductible; this is a planning model, not a prediction of a claim settlement. Your policy may use item limits, new-for-old rules, exclusions, first-loss cover or a different treatment of underinsurance.',
+  labelPrivacyNote: 'Your inventory stays in this browser. No account, upload or server calculation is required.',
+  labelAmountPlaceholder: '0.00',
+  labelCategoryFurniture: 'Furniture and decor',
+  labelCategoryElectronics: 'Electronics',
+  labelCategoryClothing: 'Clothing and shoes',
+  labelCategoryKitchen: 'Kitchen and appliances',
+  labelCategoryPersonal: 'Personal items',
+  labelCategoryOther: 'Other contents',
+};
+
+const slug = 'renter-insurance-coverage-gap-calculator';
+const title = 'Renter Insurance Coverage Gap Calculator';
+const description = 'Estimate whether your renters contents coverage limit reaches the replacement value of your belongings. Compare your inventory, policy limit, deductible and an illustrative loss scenario in your browser.';
+
+const faq = [
+  { question: 'What does this renters insurance coverage calculator measure?', answer: 'It adds the replacement values you enter for household contents and compares that total with your policy contents limit. The difference is a planning estimate of the amount that may sit outside the limit.' },
+  { question: 'Which value should I use for my contents inventory?', answer: 'Use a realistic current replacement estimate for all belongings covered by the contents section, including furniture, electronics, clothing, appliances and personal items. Check whether your policy asks for new-for-old or another valuation basis.' },
+  { question: 'Does the result prove that I am underinsured?', answer: 'No. The result is only as good as your inventory, policy wording and valuation assumptions. Item sublimits, exclusions, special schedules and clauses about underinsurance can change a claim.' },
+  { question: 'Why does the calculator show an illustrative payout?', answer: 'It shows what a simple proportional model would produce for the loss amount you enter, after the deductible. It is included to make the effect of a gap tangible, but it does not predict what an insurer will pay.' },
+  { question: 'Should I include my landlord\'s fixtures and fittings?', answer: 'Only include items that belong in your contents cover and follow your policy wording. Tenants liability, buildings, fixtures and contents can be separate sections, so do not merge them just to increase the inventory total.' },
+];
+
+const howTo = [
+  { name: 'Build a replacement inventory', text: 'Walk through each room and enter what it would cost to replace the contents today. Group items into the six categories so the largest sources of value remain visible.' },
+  { name: 'Enter the contents limit', text: 'Copy the contents sum insured from your policy schedule or quote. Do not use the buildings limit or a liability limit.' },
+  { name: 'Add the deductible and test a loss', text: 'Enter the deductible for contents claims and a sample loss amount to see an illustrative out-of-pocket scenario.' },
+  { name: 'Review the decision boundary', text: 'If a gap appears, revisit expensive items, single-item limits, valuables and recent purchases with the insurer or broker before relying on the policy.' },
+];
+
+export const content: ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  seo: [
+    { type: 'title', text: 'Check the limit against the value of your belongings', level: 2 },
+    { type: 'paragraph', html: '<p>Renters contents insurance is easiest to underestimate when the limit is chosen as a round number rather than built from a room-by-room inventory. This calculator turns your own replacement estimates into a visible coverage boundary, so you can see whether the policy limit leaves a gap before you need to claim.</p>' },
+    { type: 'title', text: 'What to gather before calculating', level: 2 },
+    { type: 'list', items: ['A replacement estimate for furniture, electronics, clothing, appliances and personal items.', 'The contents limit from the policy schedule, separate from buildings or liability cover.', 'The deductible or excess that applies to a contents claim.', 'A realistic sample loss if you want to explore an illustrative payout.'] },
+    { type: 'title', text: 'How to read the coverage gap', level: 2 },
+    { type: 'paragraph', html: '<p>The gap is the contents estimate above the limit. A zero gap means the two totals meet under your assumptions; it does not confirm that every item is covered. A positive gap is a prompt to inspect the valuation basis, expensive-item sublimits, exclusions and any underinsurance clause in the policy.</p>' },
+    { type: 'table', headers: ['Signal', 'What it tells you', 'Next useful action'], rows: [['Limit reaches inventory', 'The entered limit is at least the entered replacement total.', 'Check valuables, item limits and policy exclusions.'], ['Small gap to review', 'The limit is close, but recent purchases or rounding could matter.', 'Recheck the biggest categories and update the schedule if needed.'], ['Contents are underinsured', 'The entered limit is materially below the replacement total.', 'Ask for a revised quote or confirm how the policy handles underinsurance.']] },
+    { type: 'title', text: 'Limits of the estimate', level: 2 },
+    { type: 'paragraph', html: '<p>This tool does not read a policy, decide whether a loss is covered or calculate a binding settlement. The payout scenario uses a simple proportional model and subtracts the deductible. Real policies may use different clauses, item limits, valuation rules, exclusions or first-loss arrangements.</p>' },
+    { type: 'tip', title: 'Evidence tip', html: '<p>Keep receipts, photographs and a dated inventory for high-value belongings. The Financial Ombudsman Service explains why consumers can be underinsured when they do not calculate the full replacement cost of contents, while Spanish insurance law describes the sum insured as the maximum indemnity and sets a proportional rule for underinsurance unless the policy says otherwise.</p>' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) },
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } },
+  ],
+};

package/src/tool/renterInsuranceCoverageGapCalculator/i18n/es.ts

@@ -0,0 +1,38 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { RenterInsuranceCoverageGapCalculatorUI } from '../ui';
+export const ui: RenterInsuranceCoverageGapCalculatorUI = {
+  labelPolicyLimit: 'Límite de contenido asegurado', labelDeductible: 'Franquicia', labelSampleLoss: 'Siniestro de ejemplo', labelCurrency: 'Moneda', labelApproximateRates: 'La conversión usa factores aproximados para planificar, no tipos de cambio en tiempo real.', labelPolicyBoundary: 'Límite de la póliza', labelSetLimit: 'Fija el límite', labelPolicyBoundaryHint: 'Usa las cifras de contenido de tu póliza y prueba después una posible pérdida.', labelInventory: 'Inventario de reposición', labelInventoryHint: 'Calcula por categoría cuánto costaría sustituirlo todo hoy.', labelPolicyLimitHelp: 'Usa el límite del contenido de la póliza, no el límite del edificio.', labelDeductibleHelp: 'Introduce la franquicia aplicable a un siniestro de contenido.', labelSampleLossHelp: 'Solo sirve para mostrar un siniestro orientativo después de detectar la brecha.', labelTotalContents: 'Valor estimado del contenido', labelCoverageGap: 'Posible brecha de cobertura', labelCoverageRatio: 'Proporción cubierta estimada', labelEstimatedPayout: 'Indemnización orientativa', labelOutOfPocket: 'Pago de tu bolsillo orientativo', labelStatus: 'Lectura de cobertura', labelStatusSafe: 'El límite alcanza el inventario', labelStatusReview: 'Revisa una brecha pequeña', labelStatusExposed: 'El contenido está infrasegurado', labelStatusSafeText: 'El límite de contenido indicado es igual o superior al inventario de reposición. Comprueba aparte los límites de objetos especiales.', labelStatusReviewText: 'El límite está cerca del inventario, pero queda una brecha pequeña. Revisa los objetos caros y las compras recientes.', labelStatusExposedText: 'El límite está por debajo del inventario. Revisa la póliza antes de confiar en ella para una pérdida total.', labelLargestCategories: 'Mayores categorías del inventario', labelCoverageLine: 'Límite de póliza', labelReplacementValue: 'Valor de reposición', labelLimitMarker: 'Marcador del límite', labelLossScenario: 'Escenario de pérdida', labelIllustrativePayout: 'Solo orientativo: una cláusula proporcional puede no aplicarse a tu póliza.', labelReset: 'Restablecer ejemplo', labelCopy: 'Copiar resumen', labelCopied: 'Resumen copiado', labelCopyFailed: 'Copia manualmente el resultado', labelInvalidInput: 'Revisa el valor destacado', labelMethodTitle: 'Cómo funciona esta estimación', labelMethodText: 'La herramienta suma tus estimaciones por categoría y las compara con el límite de contenido. La brecha es la diferencia positiva entre ambos valores. La indemnización orientativa aplica la proporción cubierta al escenario de pérdida y resta la franquicia; es un modelo de planificación, no una predicción de liquidación. Tu póliza puede tener límites por objeto, reglas de valor a nuevo, exclusiones, cobertura a primer riesgo u otro tratamiento del infraseguro.', labelPrivacyNote: 'Tu inventario permanece en este navegador. No hace falta cuenta, subida de archivos ni cálculo en servidor.', labelAmountPlaceholder: '0,00', labelCategoryFurniture: 'Muebles y decoración', labelCategoryElectronics: 'Electrónica', labelCategoryClothing: 'Ropa y calzado', labelCategoryKitchen: 'Cocina y electrodomésticos', labelCategoryPersonal: 'Objetos personales', labelCategoryOther: 'Otros contenidos',
+};
+const slug = 'calculadora-brecha-cobertura-seguro-inquilino';
+const title = 'Calculadora de brecha de cobertura del seguro de inquilino';
+const description = 'Comprueba si el límite de contenido de tu seguro de inquilino alcanza el valor de reposición de tus pertenencias. Compara inventario, póliza, franquicia y un siniestro orientativo en el navegador.';
+const faq = [
+  { question: '¿Qué mide esta calculadora de cobertura para inquilinos?', answer: 'Suma los valores de reposición que introduces para el contenido de tu vivienda y los compara con el límite de la póliza. La diferencia es una estimación orientativa de lo que podría quedar fuera del límite.' },
+  { question: '¿Qué valor debo usar para mi inventario?', answer: 'Usa un coste actual y realista de reposición para muebles, electrónica, ropa, electrodomésticos y objetos personales. Comprueba si tu póliza exige valor a nuevo u otra base de valoración.' },
+  { question: '¿El resultado demuestra que estoy infrasegurado?', answer: 'No. Depende del inventario, las condiciones y las hipótesis de valoración. Los sublímites, exclusiones, objetos declarados y cláusulas de infraseguro pueden cambiar un siniestro.' },
+  { question: '¿Por qué aparece una indemnización orientativa?', answer: 'Muestra qué produciría un modelo proporcional sencillo para la pérdida indicada, después de la franquicia. Ayuda a entender la brecha, pero no predice lo que pagará la aseguradora.' },
+  { question: '¿Debo incluir las instalaciones del propietario?', answer: 'Incluye solo lo que corresponda a tu cobertura de contenido según la póliza. Responsabilidad civil, continente, instalaciones y contenido pueden ser apartados distintos y no conviene mezclarlos.' },
+];
+const howTo = [
+  { name: 'Crea un inventario de reposición', text: 'Recorre cada habitación e introduce cuánto costaría reponer hoy su contenido. Agrupa los artículos en las seis categorías para ver dónde está el mayor valor.' },
+  { name: 'Introduce el límite de contenido', text: 'Copia la suma asegurada de contenido de las condiciones o del presupuesto. No uses el límite del continente ni el de responsabilidad civil.' },
+  { name: 'Añade la franquicia y prueba una pérdida', text: 'Introduce la franquicia de los siniestros de contenido y un importe de pérdida para ver un escenario orientativo de pago propio.' },
+  { name: 'Revisa el punto de decisión', text: 'Si aparece una brecha, comprueba objetos caros, sublímites, joyas y compras recientes con la aseguradora o la correduría.' },
+];
+export const content: ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI> = { slug, title, description, ui, seo: [
+  { type: 'title', text: 'Compara el límite con el valor de tus pertenencias', level: 2 },
+  { type: 'paragraph', html: '<p>El seguro de contenido de una vivienda alquilada suele quedarse corto cuando el límite se elige como una cifra redonda y no a partir de un inventario habitación por habitación. Esta calculadora convierte tus valores de reposición en un límite visible para detectar una brecha antes de necesitar el seguro.</p>' },
+  { type: 'title', text: 'Qué debes reunir antes de calcular', level: 2 },
+  { type: 'list', items: ['Una estimación de reposición para muebles, electrónica, ropa, electrodomésticos y objetos personales.', 'El límite de contenido de la póliza, separado de continente y responsabilidad civil.', 'La franquicia que se aplica a un siniestro de contenido.', 'Una pérdida de ejemplo realista si quieres explorar la indemnización orientativa.'] },
+  { type: 'title', text: 'Cómo interpretar la brecha de cobertura', level: 2 },
+  { type: 'paragraph', html: '<p>La brecha es el valor del contenido que supera el límite. Una brecha cero significa que ambos totales coinciden según tus hipótesis; no confirma que cada objeto esté cubierto. Una brecha positiva invita a revisar la valoración, los sublímites de objetos caros, las exclusiones y cualquier cláusula de infraseguro.</p>' },
+  { type: 'table', headers: ['Señal', 'Qué indica', 'Siguiente acción útil'], rows: [['El límite alcanza el inventario', 'El límite introducido llega al total de reposición indicado.', 'Comprueba objetos valiosos, sublímites y exclusiones.'], ['Revisa una brecha pequeña', 'El límite está cerca, pero las compras recientes o el redondeo pueden importar.', 'Revisa las categorías mayores y actualiza la póliza si hace falta.'], ['El contenido está infrasegurado', 'El límite indicado queda claramente por debajo del valor de reposición.', 'Pide un presupuesto revisado o confirma cómo trata la póliza el infraseguro.']] },
+  { type: 'title', text: 'Límites de la estimación', level: 2 },
+  { type: 'paragraph', html: '<p>Esta herramienta no lee una póliza, decide si un daño está cubierto ni calcula una liquidación vinculante. El escenario usa un modelo proporcional sencillo y resta la franquicia. Las pólizas reales pueden aplicar cláusulas, límites, valoraciones, exclusiones o coberturas a primer riesgo diferentes.</p>' },
+  { type: 'tip', title: 'Consejo de prueba', html: '<p>Guarda facturas, fotografías y un inventario fechado de las pertenencias de alto valor. El Financial Ombudsman Service explica por qué se produce infraseguro cuando no se calcula el coste completo de reposición; la Ley española de Contrato de Seguro describe la suma asegurada como límite máximo de indemnización y contempla una regla proporcional salvo pacto distinto.</p>' },
+], faq, bibliography, howTo, schemas: [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) },
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+] };