@claritylabs/cl-sdk 3.2.13 → 4.0.1

package/dist/storage-sqlite.js

@@ -284,8 +284,291 @@ function createSqliteMemoryStore(db, embed) {
 }
 
 // src/source/schemas.ts
+var import_zod2 = require("zod");
+
+// src/schemas/lines-of-business.ts
 var import_zod = require("zod");
-var SourceSpanKindSchema = import_zod.z.enum([
+var ACORD_LOB_CODES = [
+  "AAPPL",
+  "AGLIA",
+  "AGPP",
+  "AGPR",
+  "AIRC",
+  "AIRPFB",
+  "APKG",
+  "APKGE",
+  "APROD",
+  "ARVP",
+  "AUTO",
+  "AUTOB",
+  "AUTOP",
+  "AVPKG",
+  "BANDM",
+  "BLANK",
+  "BMISC",
+  "BOAT",
+  "BOP",
+  "BOPGL",
+  "BOPPR",
+  "CAVN",
+  "CEQFL",
+  "CFIRE",
+  "CFRM",
+  "CGL",
+  "COMAR",
+  "COMR",
+  "CONTR",
+  "CPKGE",
+  "CPMP",
+  "CRIME",
+  "DFIRE",
+  "DISAB",
+  "DO",
+  "EDP",
+  "EL",
+  "EO",
+  "EPLI",
+  "EQ",
+  "EQPFL",
+  "EXLIA",
+  "FIDTY",
+  "FIDUC",
+  "FINEA",
+  "FLOOD",
+  "GARAG",
+  "GL",
+  "GLASS",
+  "HANG",
+  "HBB",
+  "HOME",
+  "INBR",
+  "INMAR",
+  "INMRC",
+  "INMRP",
+  "JUDCL",
+  "KIDRA",
+  "LL",
+  "MHOME",
+  "MMAL",
+  "Motorcycle",
+  "MTRTK",
+  "OLIB",
+  "PHYS",
+  "PKG",
+  "PL",
+  "PLMSC",
+  "PPKGE",
+  "PROP",
+  "PROPC",
+  "PUBOF",
+  "RECV",
+  "SCHPR",
+  "SIGNS",
+  "SMP",
+  "SURE",
+  "TRANS",
+  "TRUCK",
+  "UMBRC",
+  "UMBRL",
+  "UMBRP",
+  "UN",
+  "WCMA",
+  "WIND",
+  "WORK",
+  "WORKP",
+  "WORKV"
+];
+var AcordLobCodeSchema = import_zod.z.enum(ACORD_LOB_CODES);
+var ACORD_LOB_LABELS = {
+  AAPPL: "Aircraft / Aerial Applicator",
+  AGLIA: "Agricultural Liability",
+  AGPP: "Agricultural Personal Property",
+  AGPR: "Agricultural Property",
+  AIRC: "Aircraft",
+  AIRPFB: "Airport / Fixed Base Operator",
+  APKG: "Agricultural Package",
+  APKGE: "Agricultural Package (Extended)",
+  APROD: "Agricultural Products",
+  ARVP: "Recreational Vehicle Package",
+  AUTO: "Automobile",
+  AUTOB: "Business Auto",
+  AUTOP: "Personal Auto",
+  AVPKG: "Aviation Package",
+  BANDM: "Boiler & Machinery",
+  BLANK: "Blanket",
+  BMISC: "Business Miscellaneous",
+  BOAT: "Boat",
+  BOP: "Businessowners Policy",
+  BOPGL: "BOP - General Liability",
+  BOPPR: "BOP - Property",
+  CAVN: "Commercial Aviation",
+  CEQFL: "Contractors Equipment Floater",
+  CFIRE: "Commercial Fire",
+  CFRM: "Commercial Farm",
+  CGL: "Commercial General Liability",
+  COMAR: "Commercial Marine / Ocean Marine",
+  COMR: "Commercial (misc.)",
+  CONTR: "Contractors",
+  CPKGE: "Commercial Package",
+  CPMP: "Commercial Package (multi-peril)",
+  CRIME: "Crime",
+  DFIRE: "Dwelling Fire",
+  DISAB: "Disability",
+  DO: "Directors & Officers Liability",
+  EDP: "Electronic Data Processing",
+  EL: "Employers Liability",
+  EO: "Errors & Omissions",
+  EPLI: "Employment Practices Liability",
+  EQ: "Earthquake",
+  EQPFL: "Equipment Floater",
+  EXLIA: "Excess Liability",
+  FIDTY: "Fidelity",
+  FIDUC: "Fiduciary Liability",
+  FINEA: "Fine Arts",
+  FLOOD: "Flood",
+  GARAG: "Garage",
+  GL: "General Liability",
+  GLASS: "Glass",
+  HANG: "Hangar (Aviation)",
+  HBB: "Home-Based Business",
+  HOME: "Homeowners",
+  INBR: "Inland Marine - Brokers",
+  INMAR: "Inland Marine",
+  INMRC: "Inland Marine - Commercial",
+  INMRP: "Inland Marine - Personal",
+  JUDCL: "Judicial Bonds",
+  KIDRA: "Kidnap & Ransom",
+  LL: "Liquor Liability",
+  MHOME: "Mobile Home",
+  MMAL: "Medical Malpractice",
+  Motorcycle: "Motorcycle",
+  MTRTK: "Motor Truck Cargo",
+  OLIB: "Other Liability",
+  PHYS: "Physical Damage",
+  PKG: "Package",
+  PL: "Professional Liability",
+  PLMSC: "Personal Lines Miscellaneous",
+  PPKGE: "Personal Package",
+  PROP: "Property",
+  PROPC: "Property - Commercial",
+  PUBOF: "Public Officials Liability",
+  RECV: "Recreational Vehicle",
+  SCHPR: "Scheduled Property",
+  SIGNS: "Signs",
+  SMP: "Special Multi-Peril",
+  SURE: "Surety",
+  TRANS: "Transportation",
+  TRUCK: "Trucking",
+  UMBRC: "Umbrella - Commercial",
+  UMBRL: "Umbrella",
+  UMBRP: "Umbrella - Personal",
+  UN: "Unspecified / Unknown",
+  WCMA: "Workers Comp - Monopolistic/State",
+  WIND: "Wind",
+  WORK: "Workers Compensation",
+  WORKP: "Workers Compensation (Personal/Package)",
+  WORKV: "Workers Compensation (Voluntary)"
+};
+var LEGACY_POLICY_TYPE_TO_LOB = {
+  general_liability: ["CGL"],
+  commercial_property: ["PROPC"],
+  commercial_auto: ["AUTOB"],
+  non_owned_auto: ["AUTOB"],
+  workers_comp: ["WORK"],
+  umbrella: ["UMBRC"],
+  excess_liability: ["EXLIA"],
+  professional_liability: ["EO"],
+  cyber: ["OLIB"],
+  epli: ["EPLI"],
+  directors_officers: ["DO"],
+  fiduciary_liability: ["FIDUC"],
+  crime_fidelity: ["CRIME"],
+  inland_marine: ["INMRC"],
+  builders_risk: ["INMRC"],
+  environmental: ["OLIB"],
+  ocean_marine: ["COMAR"],
+  surety: ["SURE"],
+  product_liability: ["OLIB"],
+  bop: ["BOP"],
+  management_liability_package: ["DO", "EPLI", "FIDUC"],
+  property: ["PROP"],
+  homeowners_ho3: ["HOME"],
+  homeowners_ho5: ["HOME"],
+  renters_ho4: ["HOME"],
+  condo_ho6: ["HOME"],
+  dwelling_fire: ["DFIRE"],
+  mobile_home: ["MHOME"],
+  personal_auto: ["AUTOP"],
+  personal_umbrella: ["UMBRP"],
+  flood_nfip: ["FLOOD"],
+  flood_private: ["FLOOD"],
+  earthquake: ["EQ"],
+  personal_inland_marine: ["INMRP"],
+  watercraft: ["BOAT"],
+  recreational_vehicle: ["RECV"],
+  farm_ranch: ["CFRM"],
+  life: ["UN"],
+  critical_illness: ["DISAB"],
+  disability: ["DISAB"],
+  long_term_care: ["UN"],
+  pet: ["UN"],
+  travel: ["UN"],
+  identity_theft: ["UN"],
+  title: ["UN"],
+  other: ["UN"],
+  unknown: ["UN"],
+  auto: ["AUTOB"],
+  crime: ["CRIME"],
+  crim: ["CRIME"],
+  fiduciary: ["FIDUC"],
+  d_and_o: ["DO"],
+  d_o: ["DO"],
+  homeowners: ["HOME"],
+  renters: ["HOME"],
+  flood: ["FLOOD"],
+  boat: ["BOAT"],
+  motorcycle: ["Motorcycle"]
+};
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+function canonicalLegacyKey(value) {
+  return value.trim().toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+function isLobCode(value) {
+  return typeof value === "string" && hasOwn(ACORD_LOB_LABELS, value);
+}
+function toLobCodes(values) {
+  const source = values?.filter((value) => typeof value === "string" && value.trim()) ?? [];
+  if (source.length === 0) return ["UN"];
+  const codes = [];
+  for (const value of source) {
+    const trimmed = value.trim();
+    if (isLobCode(trimmed)) {
+      codes.push(trimmed);
+      continue;
+    }
+    if (trimmed.toUpperCase() === "CRIM") {
+      codes.push("CRIME");
+      continue;
+    }
+    const mapped = LEGACY_POLICY_TYPE_TO_LOB[canonicalLegacyKey(trimmed)];
+    if (mapped) {
+      codes.push(...mapped);
+      continue;
+    }
+    const upper = trimmed.toUpperCase();
+    if (isLobCode(upper)) {
+      codes.push(upper);
+      continue;
+    }
+    codes.push("UN");
+  }
+  return Array.from(new Set(codes));
+}
+
+// src/source/schemas.ts
+var SourceSpanKindSchema = import_zod2.z.enum([
   "pdf_text",
   "pdf_image",
   "html",
@@ -293,7 +576,7 @@ var SourceSpanKindSchema = import_zod.z.enum([
   "plain_text",
   "structured_field"
 ]);
-var SourceSpanUnitSchema = import_zod.z.enum([
+var SourceSpanUnitSchema = import_zod2.z.enum([
   "page",
   "section",
   "table",
@@ -302,78 +585,78 @@ var SourceSpanUnitSchema = import_zod.z.enum([
   "key_value",
   "text"
 ]);
-var SourceKindSchema = import_zod.z.enum([
+var SourceKindSchema = import_zod2.z.enum([
   "policy_pdf",
   "application_pdf",
   "email",
   "attachment",
   "manual_note"
 ]);
-var SourceSpanBBoxSchema = import_zod.z.object({
-  page: import_zod.z.number().int().positive(),
-  x: import_zod.z.number(),
-  y: import_zod.z.number(),
-  width: import_zod.z.number(),
-  height: import_zod.z.number()
+var SourceSpanBBoxSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().positive(),
+  x: import_zod2.z.number(),
+  y: import_zod2.z.number(),
+  width: import_zod2.z.number(),
+  height: import_zod2.z.number()
 });
-var SourceSpanLocationSchema = import_zod.z.object({
-  page: import_zod.z.number().int().positive().optional(),
-  startPage: import_zod.z.number().int().positive().optional(),
-  endPage: import_zod.z.number().int().positive().optional(),
-  charStart: import_zod.z.number().int().nonnegative().optional(),
-  charEnd: import_zod.z.number().int().nonnegative().optional(),
-  lineStart: import_zod.z.number().int().positive().optional(),
-  lineEnd: import_zod.z.number().int().positive().optional(),
-  fieldPath: import_zod.z.string().optional()
+var SourceSpanLocationSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().positive().optional(),
+  startPage: import_zod2.z.number().int().positive().optional(),
+  endPage: import_zod2.z.number().int().positive().optional(),
+  charStart: import_zod2.z.number().int().nonnegative().optional(),
+  charEnd: import_zod2.z.number().int().nonnegative().optional(),
+  lineStart: import_zod2.z.number().int().positive().optional(),
+  lineEnd: import_zod2.z.number().int().positive().optional(),
+  fieldPath: import_zod2.z.string().optional()
 });
-var SourceSpanTableLocationSchema = import_zod.z.object({
-  tableId: import_zod.z.string().optional(),
-  rowIndex: import_zod.z.number().int().nonnegative().optional(),
-  columnIndex: import_zod.z.number().int().nonnegative().optional(),
-  columnName: import_zod.z.string().optional(),
-  rowSpanId: import_zod.z.string().optional(),
-  tableSpanId: import_zod.z.string().optional(),
-  isHeader: import_zod.z.boolean().optional()
+var SourceSpanTableLocationSchema = import_zod2.z.object({
+  tableId: import_zod2.z.string().optional(),
+  rowIndex: import_zod2.z.number().int().nonnegative().optional(),
+  columnIndex: import_zod2.z.number().int().nonnegative().optional(),
+  columnName: import_zod2.z.string().optional(),
+  rowSpanId: import_zod2.z.string().optional(),
+  tableSpanId: import_zod2.z.string().optional(),
+  isHeader: import_zod2.z.boolean().optional()
 });
-var SourceSpanSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1),
-  documentId: import_zod.z.string().min(1),
+var SourceSpanSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
   sourceKind: SourceKindSchema.optional(),
-  chunkId: import_zod.z.string().optional(),
+  chunkId: import_zod2.z.string().optional(),
   kind: SourceSpanKindSchema,
-  text: import_zod.z.string(),
-  hash: import_zod.z.string().min(1),
-  textHash: import_zod.z.string().optional(),
-  pageStart: import_zod.z.number().int().positive().optional(),
-  pageEnd: import_zod.z.number().int().positive().optional(),
-  sectionId: import_zod.z.string().optional(),
-  formNumber: import_zod.z.string().optional(),
+  text: import_zod2.z.string(),
+  hash: import_zod2.z.string().min(1),
+  textHash: import_zod2.z.string().optional(),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  sectionId: import_zod2.z.string().optional(),
+  formNumber: import_zod2.z.string().optional(),
   sourceUnit: SourceSpanUnitSchema.optional(),
-  parentSpanId: import_zod.z.string().optional(),
+  parentSpanId: import_zod2.z.string().optional(),
   table: SourceSpanTableLocationSchema.optional(),
-  bbox: import_zod.z.array(SourceSpanBBoxSchema).optional(),
+  bbox: import_zod2.z.array(SourceSpanBBoxSchema).optional(),
   location: SourceSpanLocationSchema.optional(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
 });
-var SourceSpanRefSchema = import_zod.z.object({
-  sourceSpanId: import_zod.z.string().min(1),
-  documentId: import_zod.z.string().min(1).optional(),
-  chunkId: import_zod.z.string().optional(),
-  quote: import_zod.z.string().optional(),
-  hash: import_zod.z.string().optional(),
+var SourceSpanRefSchema = import_zod2.z.object({
+  sourceSpanId: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1).optional(),
+  chunkId: import_zod2.z.string().optional(),
+  quote: import_zod2.z.string().optional(),
+  hash: import_zod2.z.string().optional(),
   location: SourceSpanLocationSchema.optional()
 });
-var SourceChunkSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1),
-  documentId: import_zod.z.string().min(1),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)),
-  text: import_zod.z.string(),
-  textHash: import_zod.z.string().min(1),
-  pageStart: import_zod.z.number().int().positive().optional(),
-  pageEnd: import_zod.z.number().int().positive().optional(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({})
+var SourceChunkSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)),
+  text: import_zod2.z.string(),
+  textHash: import_zod2.z.string().min(1),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).default({})
 });
-var DocumentSourceNodeKindSchema = import_zod.z.enum([
+var DocumentSourceNodeKindSchema = import_zod2.z.enum([
   "document",
   "page_group",
   "page",
@@ -387,31 +670,31 @@ var DocumentSourceNodeKindSchema = import_zod.z.enum([
   "table_cell",
   "text"
 ]);
-var DocumentSourceNodeSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1),
-  documentId: import_zod.z.string().min(1),
-  parentId: import_zod.z.string().optional(),
+var DocumentSourceNodeSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
+  parentId: import_zod2.z.string().optional(),
   kind: DocumentSourceNodeKindSchema,
-  title: import_zod.z.string(),
-  description: import_zod.z.string(),
-  textExcerpt: import_zod.z.string().optional(),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)),
-  pageStart: import_zod.z.number().int().positive().optional(),
-  pageEnd: import_zod.z.number().int().positive().optional(),
-  bbox: import_zod.z.array(SourceSpanBBoxSchema).optional(),
-  order: import_zod.z.number().int().nonnegative(),
-  path: import_zod.z.string(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  textExcerpt: import_zod2.z.string().optional(),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  bbox: import_zod2.z.array(SourceSpanBBoxSchema).optional(),
+  order: import_zod2.z.number().int().nonnegative(),
+  path: import_zod2.z.string(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
 });
-var SourceBackedValueSchema = import_zod.z.object({
-  value: import_zod.z.string(),
-  normalizedValue: import_zod.z.string().optional(),
-  confidence: import_zod.z.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([])
+var SourceBackedValueSchema = import_zod2.z.object({
+  value: import_zod2.z.string(),
+  normalizedValue: import_zod2.z.string().optional(),
+  confidence: import_zod2.z.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
 });
-var OperationalCoverageTermSchema = import_zod.z.object({
-  kind: import_zod.z.enum([
+var OperationalCoverageTermSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum([
     "each_claim_limit",
     "each_occurrence_limit",
     "each_loss_limit",
@@ -423,334 +706,75 @@ var OperationalCoverageTermSchema = import_zod.z.object({
     "premium",
     "other"
   ]).default("other"),
-  label: import_zod.z.string(),
-  value: import_zod.z.string(),
-  amount: import_zod.z.number().optional(),
-  appliesTo: import_zod.z.string().optional(),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([])
-});
-var OperationalCoverageLineSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  coverageCode: import_zod.z.string().optional(),
-  limit: import_zod.z.string().optional(),
-  deductible: import_zod.z.string().optional(),
-  premium: import_zod.z.string().optional(),
-  retroactiveDate: import_zod.z.string().optional(),
-  formNumber: import_zod.z.string().optional(),
-  sectionRef: import_zod.z.string().optional(),
-  endorsementNumber: import_zod.z.string().optional(),
-  limits: import_zod.z.array(OperationalCoverageTermSchema).default([]),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([])
+  label: import_zod2.z.string(),
+  value: import_zod2.z.string(),
+  amount: import_zod2.z.number().optional(),
+  appliesTo: import_zod2.z.string().optional(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
 });
-var OperationalPartySchema = import_zod.z.object({
-  role: import_zod.z.string(),
-  name: import_zod.z.string(),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([])
+var OperationalCoverageLineSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  coverageCode: import_zod2.z.string().optional(),
+  limit: import_zod2.z.string().optional(),
+  deductible: import_zod2.z.string().optional(),
+  premium: import_zod2.z.string().optional(),
+  retroactiveDate: import_zod2.z.string().optional(),
+  formNumber: import_zod2.z.string().optional(),
+  sectionRef: import_zod2.z.string().optional(),
+  endorsementNumber: import_zod2.z.string().optional(),
+  limits: import_zod2.z.array(OperationalCoverageTermSchema).default([]),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
 });
-var OperationalEndorsementSupportSchema = import_zod.z.object({
-  kind: import_zod.z.string(),
-  status: import_zod.z.enum(["supported", "excluded", "requires_review"]),
-  summary: import_zod.z.string(),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([])
+var OperationalPartySchema = import_zod2.z.object({
+  role: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
 });
-var PolicyOperationalProfileSchema = import_zod.z.object({
-  documentType: import_zod.z.enum(["policy", "quote"]).default("policy"),
-  policyTypes: import_zod.z.array(import_zod.z.string()).default(["other"]),
-  policyNumber: SourceBackedValueSchema.optional(),
-  namedInsured: SourceBackedValueSchema.optional(),
-  insurer: SourceBackedValueSchema.optional(),
-  broker: SourceBackedValueSchema.optional(),
-  effectiveDate: SourceBackedValueSchema.optional(),
-  expirationDate: SourceBackedValueSchema.optional(),
-  retroactiveDate: SourceBackedValueSchema.optional(),
-  premium: SourceBackedValueSchema.optional(),
-  coverages: import_zod.z.array(OperationalCoverageLineSchema).default([]),
-  parties: import_zod.z.array(OperationalPartySchema).default([]),
-  endorsementSupport: import_zod.z.array(OperationalEndorsementSupportSchema).default([]),
-  sourceNodeIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod.z.array(import_zod.z.string().min(1)).default([]),
-  warnings: import_zod.z.array(import_zod.z.string()).default([])
+var OperationalEndorsementSupportSchema = import_zod2.z.object({
+  kind: import_zod2.z.string(),
+  status: import_zod2.z.enum(["supported", "excluded", "requires_review"]),
+  summary: import_zod2.z.string(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
 });
-
-// src/schemas/enums.ts
-var import_zod2 = require("zod");
-var PolicyTypeSchema = import_zod2.z.enum([
-  // Commercial lines
-  "general_liability",
-  "commercial_property",
-  "commercial_auto",
-  "non_owned_auto",
-  "workers_comp",
-  "umbrella",
-  "excess_liability",
-  "professional_liability",
-  "cyber",
-  "epli",
-  "directors_officers",
-  "fiduciary_liability",
-  "crime_fidelity",
-  "inland_marine",
-  "builders_risk",
-  "environmental",
-  "ocean_marine",
-  "surety",
-  "product_liability",
-  "bop",
-  "management_liability_package",
-  "property",
-  // Personal lines
-  "homeowners_ho3",
-  "homeowners_ho5",
-  "renters_ho4",
-  "condo_ho6",
-  "dwelling_fire",
-  "mobile_home",
-  "personal_auto",
-  "personal_umbrella",
-  "flood_nfip",
-  "flood_private",
-  "earthquake",
-  "personal_inland_marine",
-  "watercraft",
-  "recreational_vehicle",
-  "farm_ranch",
-  "life",
-  "critical_illness",
-  "disability",
-  "long_term_care",
-  "pet",
-  "travel",
-  "identity_theft",
-  "title",
-  "other"
-]);
-var POLICY_TYPES = PolicyTypeSchema.options;
-var EndorsementTypeSchema = import_zod2.z.enum([
-  "additional_insured",
-  "waiver_of_subrogation",
-  "primary_noncontributory",
-  "blanket_additional_insured",
-  "loss_payee",
-  "mortgage_holder",
-  "broadening",
-  "restriction",
-  "exclusion",
-  "amendatory",
-  "notice_of_cancellation",
-  "designated_premises",
-  "classification_change",
-  "schedule_update",
-  "deductible_change",
-  "limit_change",
-  "territorial_extension",
-  "other"
-]);
-var ENDORSEMENT_TYPES = EndorsementTypeSchema.options;
-var ConditionTypeSchema = import_zod2.z.enum([
-  "duties_after_loss",
-  "notice_requirements",
-  "other_insurance",
-  "cancellation",
-  "nonrenewal",
-  "transfer_of_rights",
-  "liberalization",
-  "arbitration",
-  "concealment_fraud",
-  "examination_under_oath",
-  "legal_action",
-  "loss_payment",
-  "appraisal",
-  "mortgage_holders",
-  "policy_territory",
-  "separation_of_insureds",
-  "other"
-]);
-var CONDITION_TYPES = ConditionTypeSchema.options;
-var PolicySectionTypeSchema = import_zod2.z.enum([
-  "declarations",
-  "insuring_agreement",
-  "policy_form",
-  "endorsement",
-  "application",
-  "exclusion",
-  "condition",
-  "definition",
-  "schedule",
-  "notice",
-  "regulatory",
-  "other"
-]);
-var POLICY_SECTION_TYPES = PolicySectionTypeSchema.options;
-var QuoteSectionTypeSchema = import_zod2.z.enum([
-  "terms_summary",
-  "premium_indication",
-  "underwriting_condition",
-  "subjectivity",
-  "coverage_summary",
-  "exclusion",
-  "other"
-]);
-var QUOTE_SECTION_TYPES = QuoteSectionTypeSchema.options;
-var CoverageFormSchema = import_zod2.z.enum(["occurrence", "claims_made", "accident"]);
-var COVERAGE_FORMS = CoverageFormSchema.options;
-var PolicyTermTypeSchema = import_zod2.z.enum(["fixed", "continuous"]);
-var POLICY_TERM_TYPES = PolicyTermTypeSchema.options;
-var CoverageTriggerSchema = import_zod2.z.enum(["occurrence", "claims_made", "accident"]);
-var COVERAGE_TRIGGERS = CoverageTriggerSchema.options;
-var LimitTypeSchema = import_zod2.z.enum([
-  "per_occurrence",
-  "per_claim",
-  "aggregate",
-  "per_person",
-  "per_accident",
-  "statutory",
-  "blanket",
-  "scheduled"
-]);
-var LIMIT_TYPES = LimitTypeSchema.options;
-var DeductibleTypeSchema = import_zod2.z.enum([
-  "per_occurrence",
-  "per_claim",
-  "aggregate",
-  "percentage",
-  "waiting_period"
-]);
-var DEDUCTIBLE_TYPES = DeductibleTypeSchema.options;
-var ValuationMethodSchema = import_zod2.z.enum([
-  "replacement_cost",
-  "actual_cash_value",
-  "agreed_value",
-  "functional_replacement"
-]);
-var VALUATION_METHODS = ValuationMethodSchema.options;
-var DefenseCostTreatmentSchema = import_zod2.z.enum(["inside_limits", "outside_limits", "supplementary"]);
-var DEFENSE_COST_TREATMENTS = DefenseCostTreatmentSchema.options;
-var EntityTypeSchema = import_zod2.z.enum([
-  "corporation",
-  "llc",
-  "partnership",
-  "sole_proprietor",
-  "joint_venture",
-  "trust",
-  "nonprofit",
-  "municipality",
-  "individual",
-  "married_couple",
-  "other"
-]);
-var ENTITY_TYPES = EntityTypeSchema.options;
-var AdmittedStatusSchema = import_zod2.z.enum(["admitted", "non_admitted", "surplus_lines"]);
-var ADMITTED_STATUSES = AdmittedStatusSchema.options;
-var AuditTypeSchema = import_zod2.z.enum([
-  "annual",
-  "semi_annual",
-  "quarterly",
-  "monthly",
-  "self",
-  "physical",
-  "none"
-]);
-var AUDIT_TYPES = AuditTypeSchema.options;
-var EndorsementPartyRoleSchema = import_zod2.z.enum([
-  "additional_insured",
-  "loss_payee",
-  "mortgage_holder",
-  "certificate_holder",
-  "notice_recipient",
-  "other"
-]);
-var ENDORSEMENT_PARTY_ROLES = EndorsementPartyRoleSchema.options;
-var ClaimStatusSchema = import_zod2.z.enum(["open", "closed", "reopened"]);
-var CLAIM_STATUSES = ClaimStatusSchema.options;
-var SubjectivityCategorySchema = import_zod2.z.enum(["pre_binding", "post_binding", "information"]);
-var SUBJECTIVITY_CATEGORIES = SubjectivityCategorySchema.options;
-var DocumentTypeSchema = import_zod2.z.enum(["policy", "quote", "binder", "endorsement", "certificate"]);
-var DOCUMENT_TYPES = DocumentTypeSchema.options;
-var ChunkTypeSchema = import_zod2.z.enum([
-  "declarations",
-  "coverage_form",
-  "endorsement",
-  "schedule",
-  "conditions",
-  "mixed"
-]);
-var CHUNK_TYPES = ChunkTypeSchema.options;
-var RatingBasisTypeSchema = import_zod2.z.enum([
-  "payroll",
-  "revenue",
-  "area",
-  "units",
-  "vehicle_count",
-  "employee_count",
-  "per_capita",
-  "dwelling_value",
-  "vehicle_value",
-  "contents_value",
-  "other"
-]);
-var RATING_BASIS_TYPES = RatingBasisTypeSchema.options;
-var VehicleCoverageTypeSchema = import_zod2.z.enum([
-  "liability",
-  "collision",
-  "comprehensive",
-  "uninsured_motorist",
-  "underinsured_motorist",
-  "medical_payments",
-  "hired_auto",
-  "non_owned_auto",
-  "cargo",
-  "physical_damage"
-]);
-var VEHICLE_COVERAGE_TYPES = VehicleCoverageTypeSchema.options;
-var HomeownersFormTypeSchema = import_zod2.z.enum(["HO-3", "HO-5", "HO-4", "HO-6", "HO-7", "HO-8"]);
-var HOMEOWNERS_FORM_TYPES = HomeownersFormTypeSchema.options;
-var DwellingFireFormTypeSchema = import_zod2.z.enum(["DP-1", "DP-2", "DP-3"]);
-var DWELLING_FIRE_FORM_TYPES = DwellingFireFormTypeSchema.options;
-var FloodZoneSchema = import_zod2.z.enum(["A", "AE", "AH", "AO", "AR", "V", "VE", "B", "C", "X", "D"]);
-var FLOOD_ZONES = FloodZoneSchema.options;
-var ConstructionTypeSchema = import_zod2.z.enum(["frame", "masonry", "superior", "mixed", "other"]);
-var CONSTRUCTION_TYPES = ConstructionTypeSchema.options;
-var RoofTypeSchema = import_zod2.z.enum(["asphalt_shingle", "tile", "metal", "slate", "flat", "wood_shake", "other"]);
-var ROOF_TYPES = RoofTypeSchema.options;
-var FoundationTypeSchema = import_zod2.z.enum(["basement", "crawl_space", "slab", "pier", "other"]);
-var FOUNDATION_TYPES = FoundationTypeSchema.options;
-var PersonalAutoUsageSchema = import_zod2.z.enum(["pleasure", "commute", "business", "farm"]);
-var PERSONAL_AUTO_USAGES = PersonalAutoUsageSchema.options;
-var LossSettlementSchema = import_zod2.z.enum([
-  "replacement_cost",
-  "actual_cash_value",
-  "extended_replacement_cost",
-  "guaranteed_replacement_cost"
-]);
-var LOSS_SETTLEMENTS = LossSettlementSchema.options;
-var BoatTypeSchema = import_zod2.z.enum(["sailboat", "powerboat", "pontoon", "jet_ski", "kayak_canoe", "yacht", "other"]);
-var BOAT_TYPES = BoatTypeSchema.options;
-var RVTypeSchema = import_zod2.z.enum(["rv_motorhome", "travel_trailer", "atv", "snowmobile", "golf_cart", "dirt_bike", "other"]);
-var RV_TYPES = RVTypeSchema.options;
-var ScheduledItemCategorySchema = import_zod2.z.enum([
-  "jewelry",
-  "fine_art",
-  "musical_instruments",
-  "silverware",
-  "furs",
-  "cameras",
-  "collectibles",
-  "firearms",
-  "golf_equipment",
-  "other"
-]);
-var SCHEDULED_ITEM_CATEGORIES = ScheduledItemCategorySchema.options;
-var TitlePolicyTypeSchema = import_zod2.z.enum(["owners", "lenders"]);
-var TITLE_POLICY_TYPES = TitlePolicyTypeSchema.options;
-var PetSpeciesSchema = import_zod2.z.enum(["dog", "cat", "other"]);
-var PET_SPECIES = PetSpeciesSchema.options;
-
-// src/source/policy-types.ts
-var POLICY_TYPE_KEYS = new Set(POLICY_TYPES);
+function legacyOperationalProfileInput(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if ("linesOfBusiness" in record) return value;
+  if (!("policyTypes" in record)) return value;
+  return {
+    ...record,
+    linesOfBusiness: record.policyTypes
+  };
+}
+var OperationalLinesOfBusinessSchema = import_zod2.z.preprocess(
+  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
+  import_zod2.z.array(AcordLobCodeSchema).default(["UN"])
+);
+var PolicyOperationalProfileSchema = import_zod2.z.preprocess(
+  legacyOperationalProfileInput,
+  import_zod2.z.object({
+    documentType: import_zod2.z.enum(["policy", "quote"]).default("policy"),
+    linesOfBusiness: OperationalLinesOfBusinessSchema,
+    policyNumber: SourceBackedValueSchema.optional(),
+    namedInsured: SourceBackedValueSchema.optional(),
+    insurer: SourceBackedValueSchema.optional(),
+    broker: SourceBackedValueSchema.optional(),
+    effectiveDate: SourceBackedValueSchema.optional(),
+    expirationDate: SourceBackedValueSchema.optional(),
+    retroactiveDate: SourceBackedValueSchema.optional(),
+    premium: SourceBackedValueSchema.optional(),
+    coverages: import_zod2.z.array(OperationalCoverageLineSchema).default([]),
+    parties: import_zod2.z.array(OperationalPartySchema).default([]),
+    endorsementSupport: import_zod2.z.array(OperationalEndorsementSupportSchema).default([]),
+    sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+    sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+    warnings: import_zod2.z.array(import_zod2.z.string()).default([])
+  })
+);
 
 // src/source/retrieval.ts
 function evidenceTieBreakId(evidence) {