Insurify

bowmark.providers.insurify.getAutoQuotes(query: insurifyAutoQuotesQuery): Promise<insurifyAutoQuotes>
bowmark.providers.insurify.getCityRates(query: insurifyCityRatesQuery): Promise<insurifyCityRates>
bowmark.providers.insurify.getStateRates(query: insurifyStateRatesQuery): Promise<insurifyStateRates>
bowmark.providers.insurify.getVehicleRates(query: insurifyVehicleQuery): Promise<insurifyVehicleRates>
bowmark.providers.insurify.getHomeQuotes(query: insurifyHomeQuotesQuery): Promise<insurifyHomeQuotes>
bowmark.providers.insurify.getRentersQuotes(query: insurifyRentersQuotesQuery): Promise<insurifyRentersQuotes>
bowmark.providers.insurify.listInsightsReports(query?: insurifyInsightsReportsQuery): Promise<insurifyInsightsReports>
bowmark.providers.insurify.getCarrierReview(query: insurifyCarrierReviewQuery): Promise<insurifyCarrierReview>
bowmark.providers.insurify.getCarrierUserReviews(query: insurifyCarrierUserReviewsQuery): Promise<insurifyCarrierUserReviews>
bowmark.providers.insurify.rankCarriers(query: insurifyRankCarriersQuery): Promise<insurifyCarrierRanking>

interface insurifyCityRatesQuery {
  state: string;
  city: string;
}

interface insurifyCarrierRate {
  carrier: string;
  monthlyLiabilityOnly: number | null;
  monthlyFullCoverage: number | null;
}

interface insurifyCityRates {
  city: string;
  stateSlug: string;
  citySlug: string;
  url: string;
  averageMonthly: {
    overall: number | null;
    liabilityOnly: number | null;
    fullCoverage: number | null;
  };
  cheapestCarriers: insurifyCarrierRate[];
  asOf: string | null;
}

interface insurifyStateRatesQuery {
  state: string; // postal code ("OH") or name ("Ohio", "Washington DC")
}

interface insurifyStateRates {
  state: string; // as the site names it — "Ohio", "Washington, D.C."
  stateSlug: string;
  url: string; // the state page `cheapestCarriers` was read from
  averagesUrl: string; // the states INDEX — a different document, its own schedule
  averageMonthlyLiabilityOnly: number | null;
  averageMonthlyFullCoverage: number | null;
  rankLiabilityOnly: number | null; // 1-based, 1 = CHEAPEST. Never a national average
  rankFullCoverage: number | null;
  jurisdictionsRanked: number; // what the ranks are out of (measured: 50)
  cheapestCarriers: insurifyCarrierRate[]; // the site's GENERAL table only; [] is real
  asOf: string | null; // the state page's date — describes cheapestCarriers
  averagesAsOf: string | null; // the index's date — describes the averages and ranks
}

interface insurifyVehicleQuery {
  make: string;
  model: string;
  year?: number;
}

interface insurifyVehicleCarrierRate {
  carrier: string;
  monthlyAverage: number | null;
  monthlyLiabilityOnly: number | null;
  monthlyFullCoverage: number | null;
}

type insurifyRankingKind = "best" | "cheapest";

interface insurifyRankCarriersQuery {
  ranking: insurifyRankingKind;
}

interface insurifyRankedCarrier {
  carrier: string;
  iqScore: number | null;
  userReviewScore: number | null;
  userReviewCount: number | null;
  bestFor: string | null;
  monthlyLiabilityOnly: number | null;
  monthlyFullCoverage: number | null;
}

interface insurifyVehicleYearRates {
  year: number;
  monthlyAverage: number | null;
  msrp: number | null;
  carriers: insurifyVehicleCarrierRate[];
}

interface insurifyVehicleRates {
  makeSlug: string;
  modelSlug: string;
  vehicle: string;
  url: string;
  nationalMonthlyOverall: number | null;
  nationalMonthlyLiabilityOnly: number | null;
  nationalMonthlyFullCoverage: number | null;
  modelYears: insurifyVehicleYearRates[];
  asOf: string | null;
}

interface insurifyCarrierRanking {
  ranking: insurifyRankingKind;
  url: string;
  carriers: insurifyRankedCarrier[];
  cheapestMonthlyLiabilityOnly: number | null;
  cheapestMonthlyFullCoverage: number | null;
  asOf: string | null;
}
interface insurifyAutoVehicle {
  make: string; // "Toyota"
  model: string; // "RAV4"
  year: number;
  trim?: string; // defaults to the site's "Base"
  annualMileage?: number;
  ownership?: "OWNED" | "LEASED" | "LIEN";
  purpose?: "CM" | "PL" | "BU" | "FM" | "RS"; // commute / pleasure / business / farm / rideshare
  deductible?: number; // the comp AND collision deductible REQUESTED
}

interface insurifyAutoQuotesQuery {
  // The CALLER's own details. Required — Insurify prices nothing without them.
  identity: {
    firstName: string;
    lastName: string;
    dob: string; // ISO YYYY-MM-DD
    email: string;
    phone: string;
  };
  // REQUIRED here and optional on getHomeQuotes: measured, the auto rating hop
  // refuses an application without it (406 application_incomplete).
  gender: "male" | "female" | "non-binary";
  zipcode: string; // where the car is garaged
  address: string; // street address of that garage
  vehicles: insurifyAutoVehicle[]; // at least one
  creditBand?: string; // self-reported; omitted when not given
  education?: string; // the site's own codes. Unset sends NOTHING — it is a rating
  //                     factor, so no level is invented. Note "DeclinedToProvide" is
  //                     legal in the enum but REJECTED outside CA/NY/MI.
  licenseAge?: number;
  maritalStatus?: "S" | "M";
  ownsHome?: boolean;
  currentlyInsured?: boolean;
  insuredMonths?: number;
}

interface insurifyAutoLimit {
  // "none" = not on the policy; "rejected" = offered and declined; "absent"/"unknown"
  // = the site said nothing, or said something this does not decode. The last two
  // never count as a coverage shortfall.
  status: "included" | "none" | "rejected" | "absent" | "unknown";
  perPerson: number | null; // split limits ("30000/60000")
  perAccident: number | null;
  amount: number | null; // a single figure; null on split limits
  raw: string; // the site's own string, verbatim
}

interface insurifyAutoCoverageLine {
  code: string; // BI, PD, PIP, UM, UNDUM, UMPD, RREIM, COMP, COLL
  vehicleId: string | null; // the site's own id on per-vehicle lines (COMP/COLL)
  requested: insurifyAutoLimit; // what this call asked for
  received: insurifyAutoLimit; // what the carrier actually wrote
  differs: boolean;
}

interface insurifyAutoPaymentPlan {
  paymentCadence: string | null; // null = a single payment for the whole term
  cadenceAmount: number | null;
  installmentAmount: number | null;
  fullTermAmount: number | null;
  downPaymentAmount: number | null;
  installments: number | null;
  estimated: boolean;
  selected: boolean;
}

interface insurifyAutoCarrierRatings {
  combinedScore: number | null;
  combinedTier: string | null;
  amBest: string | null;
  bbb: string | null;
  jdPower: number | null;
}

interface insurifyAutoQuote {
  carrier: string;
  carrierSlug: string;
  fullTermAmount: number | null; // THE comparable figure, over policyLengthMonths
  policyLengthMonths: number | null; // 6 on auto where home is 12 — read, not assumed
  cadenceAmount: number | null;
  paymentCadence: string | null;
  installmentAmount: number | null;
  downPaymentAmount: number | null;
  installments: number | null;
  estimated: boolean;
  quoteNumber: string | null;
  bindUrl: string | null;
  bridgeUrl: string | null;
  bindable: boolean; // from contactMethods OR either online destination, not bindUrl alone
  contactMethods: string[]; // buy_online / online_bind / call
  agency: string | null;
  agencyPhone: string | null;
  ratings: insurifyAutoCarrierRatings | null;
  highlights: string[]; // marketing copy, never coverage
  coverages: insurifyAutoCoverageLine[];
  missingRequestedCoverages: string[]; // codes asked for and dropped OR written weaker
  paymentPlans: insurifyAutoPaymentPlan[];
}

interface insurifyAutoReferral {
  carrier: string;
  carrierSlug: string | null;
  headline: string | null;
  description: string | null;
  displayUrl: string | null;
  position: number | null;
}

interface insurifyAutoQuotes {
  zipcode: string;
  address: string;
  city: string | null;
  state: string | null;
  quotes: insurifyAutoQuote[]; // priced offers
  referrals: insurifyAutoReferral[]; // paid placements, never rates
  cheapestFullTermAmount: number | null; // cheapest PRICE — may cover less
  cheapestFullTermAmountWithRequestedCoverage: number | null; // cheapest LIKE-FOR-LIKE
  applicationId: number | null;
  completed: boolean; // did the site finish quoting, or did we stop polling first
  fullSet: boolean; // the site's SECOND completeness flag; can be false while completed is true
  throttled: boolean; // the site rate-limited this request — rows may be a fraction of the market
}

interface insurifyHomeProperty {
  address: string;
  zipcode: string;
  secondaryAddress?: string;
  homeType?: "DW" | "DU" | "MF" | "MH" | "CD" | "TH";
  yearBuilt?: number;
  squareFootage?: number;
  bedrooms?: number;
  bathrooms?: number;
  stories?: number;
  roofType?: "asphalt_shingles" | "clay_tile" | "concrete_tile" | "steel" | "other";
  foundation?: "slab" | "crawl_space" | "basement" | "pier_and_beam" | "other";
  homeUse?: "primary_home" | "secondary_home";
  swimmingPool?: boolean;
  trampoline?: boolean;
}

interface insurifyHomeQuotesQuery {
  // The CALLER's own details. Required — Insurify prices nothing without them.
  identity: {
    firstName: string;
    lastName: string;
    dob: string; // ISO YYYY-MM-DD
    email: string;
    phone: string;
  };
  property: insurifyHomeProperty;
  creditBand?: string; // self-reported; omitted when not given
  gender?: "male" | "female" | "non-binary";
}

interface insurifyHomePaymentPlan {
  paymentCadence: string | null; // null = a single payment for the whole term
  cadenceAmount: number | null;
  fullTermAmount: number | null;
  downPaymentAmount: number | null;
  installments: number | null;
  estimated: boolean;
  selected: boolean;
}

interface insurifyHomeCoverages {
  dwelling: number | null;
  personalProperty: number | null;
  personalLiability: number | null;
  lossOfUse: number | null;
  medicalPayments: number | null;
  otherStructures: number | null;
  deductible: insurifyDeductible | null;
  windHailDeductible: insurifyDeductible | null;
}

interface insurifyDeductible {
  value: number;
  unit: "usd" | "percent"; // a homeowners deductible is either dollars or a % of dwelling
  usdAmount: number | null; // the % applied to the dwelling limit; null if it cannot be derived
}

interface insurifyHomeQuote {
  carrier: string;
  carrierSlug: string;
  fullTermAmount: number | null;
  policyLengthMonths: number | null;
  cadenceAmount: number | null;
  paymentCadence: string | null;
  downPaymentAmount: number | null;
  installments: number | null;
  estimated: boolean;
  quoteNumber: string | null;
  bindUrl: string | null;
  agency: string | null;
  agencyPhone: string | null;
  coverages: insurifyHomeCoverages;
  paymentPlans: insurifyHomePaymentPlan[];
}

interface insurifyHomeReferral {
  carrier: string;
  carrierSlug: string | null;
  headline: string | null;
  displayUrl: string | null;
  position: number | null;
}

interface insurifyHomeQuotes {
  address: string;
  zipcode: string;
  city: string | null;
  state: string | null;
  quotes: insurifyHomeQuote[];
  referrals: insurifyHomeReferral[];
  cheapestFullTermAmount: number | null;
  applicationId: number | null;
  completed: boolean;
}

type insurifyRentedHomeType = "APT" | "DW" | "DU" | "MF" | "MH" | "CD" | "TH";

interface insurifyRentedProperty {
  address: string;
  zipcode: string; // always passed explicitly — the site prefills a ZIP of its own
  secondaryAddress?: string; // unit/apt. Common on a renters policy specifically
  homeType?: insurifyRentedHomeType; // APT is the renters flow's own addition
  fireAlarm?: boolean;
  livedHereOverAYear?: boolean; // the site's own yes/no; it sends 5 or 1 years
}

interface insurifyRentersCoverageRequest {
  // Both are the site's OWN option lists, and both were MEASURED to move the
  // price rather than echo the request. Omitted when not given.
  personalProperty?: number; // 5000 / 10000 / 15000 / 20000 / 25000 / 30000
  deductible?: number; // 250 / 500 / 1000 / 2500
}

interface insurifyRentersQuotesQuery {
  // The CALLER's own details. Required — Insurify prices nothing without them.
  identity: {
    firstName: string;
    lastName: string;
    dob: string; // ISO YYYY-MM-DD
    email: string;
    phone: string;
  };
  property: insurifyRentedProperty;
  coverage?: insurifyRentersCoverageRequest;
  gender?: "male" | "female" | "non-binary"; // omitted when not given
}

interface insurifyRentersCoverages {
  // The RENTERS codes, not the homeowners ones: no dwelling, no other
  // structures, no separate wind/hail. "No coverage" becomes null, never 0.
  personalProperty: number | null; // PP — the line the caller actually chooses
  personalLiability: number | null; // PL
  lossOfUse: number | null; // LOU
  medicalPayments: number | null; // MEDPM
  deductible: number | null; // B_DED — always dollars on a renters policy
}

interface insurifyRentersPaymentPlan {
  paymentCadence: string | null; // null = a single payment for the whole term
  cadenceAmount: number | null;
  fullTermAmount: number | null; // comparable across plans AND carriers
  downPaymentAmount: number | null;
  installments: number | null; // 0 = pay in full
  estimated: boolean;
  selected: boolean; // the plan the site displays
}

interface insurifyRentersQuote {
  carrier: string;
  carrierSlug: string;
  fullTermAmount: number | null; // THE comparable figure, over policyLengthMonths
  policyLengthMonths: number | null;
  cadenceAmount: number | null; // meaningless without paymentCadence beside it
  paymentCadence: string | null;
  downPaymentAmount: number | null;
  installments: number | null;
  estimated: boolean;
  quoteNumber: string | null;
  bindUrl: string | null; // returned, never followed
  agency: string | null;
  agencyPhone: string | null;
  coverages: insurifyRentersCoverages;
  paymentPlans: insurifyRentersPaymentPlan[]; // EVERY way to pay, not just the shown one
  cheapestPlanFullTermAmount: number | null; // this carrier's own best plan
}

interface insurifyRentersReferral {
  carrier: string;
  carrierSlug: string | null;
  headline: string | null;
  displayUrl: string | null;
  position: number | null; // ads and quotes are positioned in separate sequences
}

interface insurifyRentersQuotes {
  address: string;
  zipcode: string;
  city: string | null; // resolved by the site from the ZIP, not echoed
  state: string | null;
  quotes: insurifyRentersQuote[]; // priced offers
  referrals: insurifyRentersReferral[]; // paid placements, never rates
  cheapestFullTermAmount: number | null; // folds the DISPLAYED plan per row
  cheapestAvailableFullTermAmount: number | null; // folds every plan — the real floor
  applicationId: number | null;
  completed: boolean; // did the site finish quoting, or did we stop polling
  throttled: boolean; // the site rate-limited it — short BY ITS choice
  fullSet: boolean; // the site's third completeness signal; can disagree with completed
}

type insurifyReviewProduct =
  | "auto"
  | "home"
  | "renters"
  | "pet"
  | "travel"
  | "device"
  | "autoWarranty"
  | "homeWarranty"
  | "business";

interface insurifyCarrierReviewQuery {
  carrier: string; // as a person would name it — "GEICO", "State Farm", "state-farm"
  product?: insurifyReviewProduct; // defaults to "auto" (101 of the site's 198 reviews)
}

interface insurifyCarrierMetric {
  // A LABELLED metric, deliberately not "a rating": the review card is the
  // site's generic metric strip, so on car and home it holds the third-party
  // ratings and on PET it holds average prices.
  label: string; // "J.D. Power", "NAIC Index", "A.M. Best", "Mixed Breed Dog"
  value: string; // a STRING because these are not one scale — "A++", "637", "0.59", "$39"
  measures: string | null; // the site's own sentence saying what the figure measures
}

interface insurifyCarrierDiscount {
  discount: string;
  savings: string | null; // verbatim prose as often as a percentage
}

interface insurifyCarrierReview {
  carrier: string;
  carrierSlug: string;
  product: insurifyReviewProduct; // echoed from the request
  url: string;
  // EVERY figure is nullable, and a null is always "Insurify does not publish
  // this" — a page whose review card is present but unreadable throws instead.
  iqScore: number | null;
  iqScoreOutOf: number | null; // read from the page, never assumed
  methodologyUrl: string | null;
  metrics: insurifyCarrierMetric[];
  pros: string[];
  cons: string[];
  bestFor: string[];
  discounts: insurifyCarrierDiscount[]; // [] is a real answer, not a failed read
  editorialSummary: string | null;
  averageMonthlyLiabilityOnly: number | null; // auto card only; null on other verticals
  averageMonthlyFullCoverage: number | null;
  userReviewScore: number | null; // out of 5, from the block BRANDED to this carrier
  userReviewCount: number | null;
  asOf: string | null;
}

type insurifyInsightsKind = "insights" | "report";

interface insurifyInsightsReportsQuery {
  kind?: insurifyInsightsKind;
  vertical?: string; // "car-insurance", "homeowners-insurance", …
}

interface insurifyInsightsReport {
  title: string;
  summary: string | null;
  url: string;
  slug: string;
  kind: insurifyInsightsKind;
  vertical: string | null;
  lastModified: string | null; // last UPDATED, not first published
  imageUrl: string | null;
}

interface insurifyInsightsReports {
  reports: insurifyInsightsReport[];
  totalPublished: number;
  sources: string[];
  latestUpdate: string | null;
}

interface insurifyCarrierUserReviewsQuery {
  carrier: string; // as a person would name it — "GEICO", "State Farm", "state-farm"
  page?: number; // 1-based, the site's OWN pagination; past `totalPages` throws
}

interface insurifyCarrierUserReview {
  author: string; // usually a first name only
  rating: number;
  ratingOutOf: number; // read from the page's schema.org data, never assumed to be 5
  title: string | null; // ~a quarter carry none — a real absence, not a missed selector
  text: string;
  state: string | null; // null is a REAL answer: the site publishes blank-state bylines
  publishedAt: string; // ISO 8601, from schema.org rather than the rendered byline
}

interface insurifyCarrierUserReviews {
  carrier: string;
  carrierSlug: string;
  url: string;
  page: number; // read off the page's own pagination state, not echoed from the request
  totalPages: number; // the LISTING's ceiling, not the carrier's full review count
  reviews: insurifyCarrierUserReview[];
  averageRating: number | null; // across ALL ratings, not just the written ones
  averageRatingOutOf: number | null;
  ratingCount: number | null; // includes ratings with no written review
  writtenReviewCount: number | null; // routinely far larger than totalPages × rows
}