@welldot/core 0.3.0 → 0.4.0-next.20261015.d7c7365

package/dist/index.cjs

@@ -20,63 +20,184 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AQUIFER_ANALYSIS_METHODS: () => AQUIFER_ANALYSIS_METHODS,
   AirliftEventSchema: () => AirliftEventSchema,
   AquiferAnalysisSchema: () => AquiferAnalysisSchema,
   AttachmentSchema: () => AttachmentSchema,
+  BLANK_SAMPLE_TYPES: () => BLANK_SAMPLE_TYPES,
+  BR_GM_MS_888_2021: () => BR_GM_MS_888_2021,
   BoreHoleSchema: () => BoreHoleSchema,
+  CEMENT_PAD_TYPES: () => CEMENT_PAD_TYPES,
+  CENTRALIZER_TYPES: () => CENTRALIZER_TYPES,
+  CONDITION_CATEGORIES: () => CONDITION_CATEGORIES,
+  CONSTRUCTION_MATERIALS: () => CONSTRUCTION_MATERIALS,
   CaveSchema: () => CaveSchema,
   CementPadSchema: () => CementPadSchema,
   CentralizerSchema: () => CentralizerSchema,
+  ConditionFulfillmentSchema: () => ConditionFulfillmentSchema,
   ConstantRateEventSchema: () => ConstantRateEventSchema,
+  DOCUMENT_TYPES: () => DOCUMENT_TYPES,
+  DOCUMENT_TYPE_SUGGESTIONS: () => DOCUMENT_TYPE_SUGGESTIONS,
+  DRILLING_METHODS: () => DRILLING_METHODS,
+  ESTIMATION_METHODS: () => ESTIMATION_METHODS,
+  EU_2020_2184: () => EU_2020_2184,
+  EstimatedVolumeSchema: () => EstimatedVolumeSchema,
   FGDC_TEXTURES_OPTIONS: () => FGDC_TEXTURES_OPTIONS,
+  FILTRATION_LOCATION_VALUES: () => FILTRATION_LOCATION_VALUES,
+  FRACTION_VALUES: () => FRACTION_VALUES,
+  FiltrationSchema: () => FiltrationSchema,
   FractureSchema: () => FractureSchema,
+  HISTORY_LOG_CATEGORIES: () => HISTORY_LOG_CATEGORIES,
+  HISTORY_LOG_SEVERITIES: () => HISTORY_LOG_SEVERITIES,
+  HYDRODYNAMIC_EVENT_TYPES: () => HYDRODYNAMIC_EVENT_TYPES,
   HistoryLogEntrySchema: () => HistoryLogEntrySchema,
   HoleFillSchema: () => HoleFillSchema,
   HydrodynamicEventBaseSchema: () => HydrodynamicEventBaseSchema,
   HydrodynamicEventSchema: () => HydrodynamicEventSchema,
+  LaboratorySchema: () => LaboratorySchema,
   LevelReadingSchema: () => LevelReadingSchema,
   LithologySchema: () => LithologySchema,
   LocationPropertiesSchema: () => LocationPropertiesSchema,
   LocationSchema: () => LocationSchema,
+  MAINTENANCE_TYPES: () => MAINTENANCE_TYPES,
+  MEASURED_IN_VALUES: () => MEASURED_IN_VALUES,
+  MEASUREMENT_LOCATIONS: () => MEASUREMENT_LOCATIONS,
+  MEASUREMENT_METHODS: () => MEASUREMENT_METHODS,
+  METER_TYPES: () => METER_TYPES,
+  MeterReadingSchema: () => MeterReadingSchema,
+  MeterSchema: () => MeterSchema,
+  MonthlyGrantSchema: () => MonthlyGrantSchema,
+  NEPHELOMETRIC_TURBIDITY_CODES: () => NEPHELOMETRIC_TURBIDITY_CODES,
+  NUMERIC_QUALIFIERS: () => NUMERIC_QUALIFIERS,
+  OperatingRegimeSchema: () => OperatingRegimeSchema,
+  PARAMETER_GROUPS: () => PARAMETER_GROUPS,
+  PARAMETER_GROUP_VALUES: () => PARAMETER_GROUP_VALUES,
+  PARENT_SAMPLE_TYPES: () => PARENT_SAMPLE_TYPES,
+  PERMIT_ADMINISTRATIVE_STATUSES: () => PERMIT_ADMINISTRATIVE_STATUSES,
+  PERMIT_ADMINISTRATIVE_STATUS_VALUES: () => PERMIT_ADMINISTRATIVE_STATUS_VALUES,
+  PERMIT_HISTORY_TYPES: () => PERMIT_HISTORY_TYPES,
+  PERMIT_TYPES: () => PERMIT_TYPES,
+  POWER_SOURCES: () => POWER_SOURCES,
+  PRODUCTION_ENTRY_TYPES: () => PRODUCTION_ENTRY_TYPES,
+  PUMP_TYPES: () => PUMP_TYPES,
+  ParameterSchema: () => ParameterSchema,
+  PermitAdministrativeStatusSchema: () => PermitAdministrativeStatusSchema,
+  PermitConditionSchema: () => PermitConditionSchema,
+  PermitHistoryEntrySchema: () => PermitHistoryEntrySchema,
+  PermitSchema: () => PermitSchema,
+  ProductionEntryBaseSchema: () => ProductionEntryBaseSchema,
+  ProductionEntrySchema: () => ProductionEntrySchema,
+  PumpElectricalSchema: () => PumpElectricalSchema,
+  PumpInstallationSchema: () => PumpInstallationSchema,
   PumpingStepSchema: () => PumpingStepSchema,
+  PurgeReadingSchema: () => PurgeReadingSchema,
+  PurgeSchema: () => PurgeSchema,
+  QUALIFIER_VALUES: () => QUALIFIER_VALUES,
+  READING_SOURCES: () => READING_SOURCES,
+  RESULT_FRACTIONS: () => RESULT_FRACTIONS,
+  RESULT_QUALIFIERS: () => RESULT_QUALIFIERS,
   RecoveryOnlyEventSchema: () => RecoveryOnlyEventSchema,
   RecoveryPhaseSchema: () => RecoveryPhaseSchema,
   ReductionSchema: () => ReductionSchema,
+  ResultQualifierSchema: () => ResultQualifierSchema,
+  ResultValidationSchema: () => ResultValidationSchema,
+  SAMPLE_TYPES: () => SAMPLE_TYPES,
+  SAMPLING_DEVICES: () => SAMPLING_DEVICES,
+  SAMPLING_METHODS: () => SAMPLING_METHODS,
+  SAMPLING_POINT_TYPES: () => SAMPLING_POINT_TYPES,
+  SCREEN_SLOT_TYPES: () => SCREEN_SLOT_TYPES,
   SECTION_KEYS: () => SECTION_KEYS,
+  SamplingPointSchema: () => SamplingPointSchema,
   SpotMeasurementEventSchema: () => SpotMeasurementEventSchema,
   StepDrawdownEventSchema: () => StepDrawdownEventSchema,
   SurfaceCaseSchema: () => SurfaceCaseSchema,
   TextureSchema: () => TextureSchema,
+  TimeResolutionSchema: () => TimeResolutionSchema,
+  VALIDATION_STATUSES: () => VALIDATION_STATUSES,
+  VALIDATION_STATUS_VALUES: () => VALIDATION_STATUS_VALUES,
+  VISIBILITY_LEAF_KEYS: () => VISIBILITY_LEAF_KEYS,
+  VISIBILITY_TREE: () => VISIBILITY_TREE,
+  VOLUME_LIMIT_PERIODS: () => VOLUME_LIMIT_PERIODS,
+  VolumeLimitSchema: () => VolumeLimitSchema,
+  WATER_QUALITY_LIMIT_SETS: () => WATER_QUALITY_LIMIT_SETS,
+  WATER_QUALITY_PARAMETERS: () => WATER_QUALITY_PARAMETERS,
+  WATER_QUALITY_UNITS: () => WATER_QUALITY_UNITS,
+  WATER_QUALITY_VOCABULARY_VERSION: () => WATER_QUALITY_VOCABULARY_VERSION,
+  WATER_USES: () => WATER_USES,
+  WELL_PURPOSES: () => WELL_PURPOSES,
+  WELL_STATUSES: () => WELL_STATUSES,
+  WELL_STATUS_VALUES: () => WELL_STATUS_VALUES,
+  WELL_TYPES: () => WELL_TYPES,
+  WHO_GDWQ_2022: () => WHO_GDWQ_2022,
+  WaterQualityResultSchema: () => WaterQualityResultSchema,
+  WaterSampleSchema: () => WaterSampleSchema,
   WellCaseSchema: () => WellCaseSchema,
   WellIdSchema: () => WellIdSchema,
   WellSchema: () => WellSchema,
   WellScreenSchema: () => WellScreenSchema,
+  WellStatusSchema: () => WellStatusSchema,
+  calculatedWellDepth: () => calculatedWellDepth,
   checkIfProfileIsEmpty: () => checkIfProfileIsEmpty,
+  concentrationFromCanonical: () => concentrationFromCanonical,
+  concentrationToCanonical: () => concentrationToCanonical,
   convertProfileFromJSON: () => convertProfileFromJSON,
+  cubicFeetToCubicMeters: () => cubicFeetToCubicMeters,
   cubicMeterPerHourToLitersPerSecond: () => cubicMeterPerHourToLitersPerSecond,
   cubicMeterPerHourToUsGallonsPerMinute: () => cubicMeterPerHourToUsGallonsPerMinute,
+  cubicMetersToCubicFeet: () => cubicMetersToCubicFeet,
+  cubicMetersToLiters: () => cubicMetersToLiters,
+  cubicMetersToUsGallons: () => cubicMetersToUsGallons,
+  cvToKilowatts: () => cvToKilowatts,
   decimalDegreesToDms: () => decimalDegreesToDms,
   deserializeWell: () => deserializeWell,
   dmsToDecimalDegrees: () => dmsToDecimalDegrees,
+  expandedToStandardUncertainty: () => expandedToStandardUncertainty,
   feetToMeters: () => feetToMeters,
+  flowFromCanonical: () => flowFromCanonical,
+  flowToCanonical: () => flowToCanonical,
+  formatVocabList: () => formatVocabList,
+  getLimitSet: () => getLimitSet,
+  getParameterDefinition: () => getParameterDefinition,
+  getParameterLabel: () => getParameterLabel,
+  getVocabEntry: () => getVocabEntry,
+  getVocabLabel: () => getVocabLabel,
+  hasWellData: () => hasWellData,
   hoursToMinutes: () => hoursToMinutes,
+  hpToKilowatts: () => hpToKilowatts,
   inchesToMm: () => inchesToMm,
+  isKnownParameter: () => isKnownParameter,
+  isVocabValue: () => isVocabValue,
   isWellEmpty: () => isWellEmpty,
   kilopascalToPsi: () => kilopascalToPsi,
+  kilowattsToCv: () => kilowattsToCv,
+  kilowattsToHp: () => kilowattsToHp,
   litersPerSecondToCubicMeterPerHour: () => litersPerSecondToCubicMeterPerHour,
+  litersToCubicMeters: () => litersToCubicMeters,
   metersToFeet: () => metersToFeet,
+  milliSiemensPerCmToMicroSiemensPerCm: () => milliSiemensPerCmToMicroSiemensPerCm,
+  milliSiemensPerMeterToMicroSiemensPerCm: () => milliSiemensPerMeterToMicroSiemensPerCm,
   minutesToHours: () => minutesToHours,
   mmToInches: () => mmToInches,
   mmToSlotNumber: () => mmToSlotNumber,
+  normalizeColorUnit: () => normalizeColorUnit,
+  parameterKey: () => parameterKey,
   parseWell: () => parseWell,
+  powerFromCanonical: () => powerFromCanonical,
+  powerToCanonical: () => powerToCanonical,
   profileToWell: () => profileToWell,
   psiToKilopascal: () => psiToKilopascal,
   redactWell: () => redactWell,
+  resolveLanguageText: () => resolveLanguageText,
   serializeWell: () => serializeWell,
   slotNumberToMm: () => slotNumberToMm,
   squareMeterPerDayToSquareMeterPerSecond: () => squareMeterPerDayToSquareMeterPerSecond,
   squareMeterPerSecondToSquareMeterPerDay: () => squareMeterPerSecondToSquareMeterPerDay,
-  usGallonsPerMinuteToCubicMeterPerHour: () => usGallonsPerMinuteToCubicMeterPerHour
+  turbidityCodeForUnit: () => turbidityCodeForUnit,
+  usGallonsPerMinuteToCubicMeterPerHour: () => usGallonsPerMinuteToCubicMeterPerHour,
+  usGallonsToCubicMeters: () => usGallonsToCubicMeters,
+  vocabValues: () => vocabValues,
+  volumeFromCanonical: () => volumeFromCanonical,
+  volumeToCanonical: () => volumeToCanonical
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -89,8 +210,31 @@ var mergeWell = (0, import_defu.createDefu)((obj, key, value) => {
     return true;
   }
 });
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var mergeParsed = (0, import_defu.createDefu)((obj, key, value) => {
+  if (Array.isArray(value)) {
+    const raw = obj[key];
+    obj[key] = Array.isArray(raw) && raw.length === value.length ? value.map(
+      (item, i) => isPlainObject(item) && isPlainObject(raw[i]) ? mergeParsed(item, raw[i]) : item
+    ) : value;
+    return true;
+  }
+});
 var RFC3339_WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
 var rfc3339 = () => import_zod.z.string().regex(RFC3339_WITH_OFFSET, "datetime must be RFC 3339 with UTC offset");
+var CALENDAR_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var calendarDate = () => import_zod.z.string().regex(CALENDAR_DATE, "date must be YYYY-MM-DD");
+var DATE_DURATION = /^P(?=\d)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?$/;
+var dateDuration = () => import_zod.z.string().regex(DATE_DURATION, "duration must be an ISO 8601 date duration");
+var AttachmentSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  uri: import_zod.z.string().url(),
+  media_type: import_zod.z.string(),
+  document_type: import_zod.z.string().optional(),
+  filename: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  sha256: import_zod.z.string().optional()
+});
 var WellIdSchema = import_zod.z.object({
   authority: import_zod.z.string(),
   id: import_zod.z.string(),
@@ -134,7 +278,8 @@ var WellScreenSchema = import_zod.z.object({
   to: import_zod.z.number(),
   type: import_zod.z.string(),
   diameter: import_zod.z.number(),
-  screen_slot: import_zod.z.number()
+  screen_slot: import_zod.z.number(),
+  slot_type: import_zod.z.string().optional()
 });
 var HoleFillSchema = import_zod.z.object({
   from: import_zod.z.number(),
@@ -212,7 +357,9 @@ var HydrodynamicEventBaseSchema = import_zod.z.object({
   sequence: import_zod.z.number().int().optional(),
   operator: import_zod.z.string().optional(),
   equipment: import_zod.z.string().optional(),
-  notes: import_zod.z.string().optional()
+  notes: import_zod.z.string().optional(),
+  corrects: import_zod.z.string().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
 });
 var SpotMeasurementEventSchema = HydrodynamicEventBaseSchema.extend({
   type: import_zod.z.literal("spot_measurement"),
@@ -254,14 +401,13 @@ var HydrodynamicEventSchema = import_zod.z.discriminatedUnion("type", [
   AirliftEventSchema,
   RecoveryOnlyEventSchema
 ]).or(HydrodynamicEventBaseSchema.passthrough());
-var AttachmentSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  uri: import_zod.z.string().url(),
-  media_type: import_zod.z.string(),
-  filename: import_zod.z.string().optional(),
-  description: import_zod.z.string().optional(),
-  sha256: import_zod.z.string().optional()
-});
+var WellStatusSchema = import_zod.z.enum([
+  "active",
+  "maintenance",
+  "inactive",
+  "decommissioned",
+  "abandoned"
+]);
 var HistoryLogEntrySchema = import_zod.z.object({
   id: import_zod.z.string(),
   datetime: rfc3339(),
@@ -270,7 +416,13 @@ var HistoryLogEntrySchema = import_zod.z.object({
   description: import_zod.z.string(),
   author: import_zod.z.string().optional(),
   severity: import_zod.z.string().optional(),
-  attachments: import_zod.z.array(AttachmentSchema).optional()
+  attachments: import_zod.z.array(AttachmentSchema).optional(),
+  hydrodynamic_event_ids: import_zod.z.array(import_zod.z.string()).optional(),
+  sample_ids: import_zod.z.array(import_zod.z.string()).optional(),
+  maintenance_type: import_zod.z.string().optional(),
+  pump_installation_id: import_zod.z.string().optional(),
+  meter_id: import_zod.z.string().optional(),
+  status: WellStatusSchema.optional()
 });
 var AquiferAnalysisSchema = import_zod.z.object({
   id: import_zod.z.string(),
@@ -296,8 +448,297 @@ var AquiferAnalysisSchema = import_zod.z.object({
   jacob_b: import_zod.z.number().optional(),
   jacob_c: import_zod.z.number().optional(),
   well_efficiency_pct: import_zod.z.number().optional(),
+  notes: import_zod.z.string().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var PumpElectricalSchema = import_zod.z.object({
+  voltage: import_zod.z.number().nonnegative().optional(),
+  phases: import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(3)]).optional(),
+  cable_section: import_zod.z.number().nonnegative().optional(),
+  cable_length: import_zod.z.number().nonnegative().optional()
+});
+var PumpInstallationSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  installed_at: rfc3339(),
+  removed_at: rfc3339().optional(),
+  installed_by: import_zod.z.string().optional(),
+  removed_by: import_zod.z.string().optional(),
+  type: import_zod.z.string(),
+  power_source: import_zod.z.string().optional(),
+  manufacturer: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  serial: import_zod.z.string().optional(),
+  intake_depth: import_zod.z.number().nonnegative().optional(),
+  rated_flow_rate: import_zod.z.number().nonnegative().optional(),
+  rated_head: import_zod.z.number().nonnegative().optional(),
+  rated_power: import_zod.z.number().nonnegative().optional(),
+  stages: import_zod.z.number().int().positive().optional(),
+  riser_diameter: import_zod.z.number().nonnegative().optional(),
+  riser_material: import_zod.z.string().optional(),
+  check_valve: import_zod.z.boolean().optional(),
+  electrical: PumpElectricalSchema.optional(),
+  notes: import_zod.z.string().optional(),
+  updated_at: rfc3339().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var VolumeLimitSchema = import_zod.z.object({
+  period: import_zod.z.enum(["daily", "monthly", "annual"]),
+  volume: import_zod.z.number().nonnegative()
+});
+var MonthlyGrantSchema = import_zod.z.object({
+  month: import_zod.z.number().int().min(1).max(12),
+  flow_rate: import_zod.z.number().nonnegative().optional(),
+  daily_operating_time: import_zod.z.number().nonnegative().optional(),
+  days: import_zod.z.number().int().min(0).max(31).optional()
+});
+var ConditionFulfillmentSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  datetime: rfc3339(),
+  due_date: calendarDate().optional(),
+  description: import_zod.z.string().optional(),
+  author: import_zod.z.string().optional(),
+  event_id: import_zod.z.string().optional(),
+  sample_id: import_zod.z.string().optional(),
+  updated_at: rfc3339().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var PermitConditionSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  description: import_zod.z.string(),
+  category: import_zod.z.string().optional(),
+  first_due: calendarDate().optional(),
+  due_after: dateDuration().optional(),
+  recurrence: dateDuration().optional(),
+  last_due: calendarDate().optional(),
+  occurrences: import_zod.z.number().int().positive().optional(),
+  responsible: import_zod.z.string().optional(),
+  fulfillments: import_zod.z.array(ConditionFulfillmentSchema).optional()
+});
+var PermitAdministrativeStatusSchema = import_zod.z.enum([
+  "requested",
+  "granted",
+  "suspended",
+  "revoked",
+  "denied",
+  "withdrawn"
+]);
+var PermitHistoryEntrySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  date: calendarDate(),
+  type: import_zod.z.string().optional(),
+  description: import_zod.z.string(),
+  done: import_zod.z.boolean().optional(),
+  due_date: calendarDate().optional(),
+  updated_at: rfc3339().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var PermitSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.string(),
+  authority: import_zod.z.string(),
+  identifier: import_zod.z.string().optional(),
+  request_identifier: import_zod.z.string().optional(),
+  status: PermitAdministrativeStatusSchema.optional(),
+  issued_at: calendarDate().optional(),
+  valid_from: calendarDate().optional(),
+  valid_until: calendarDate().optional(),
+  renewal_requested_at: calendarDate().optional(),
+  water_use: import_zod.z.array(import_zod.z.string()).optional(),
+  flow_rate: import_zod.z.number().nonnegative().optional(),
+  daily_operating_time: import_zod.z.number().nonnegative().optional(),
+  volume_limits: import_zod.z.array(VolumeLimitSchema).optional(),
+  monthly_schedule: import_zod.z.array(MonthlyGrantSchema).optional(),
+  conditions: import_zod.z.array(PermitConditionSchema).optional(),
+  history: import_zod.z.array(PermitHistoryEntrySchema).optional(),
+  supersedes: import_zod.z.string().optional(),
+  notes: import_zod.z.string().optional(),
+  updated_at: rfc3339().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var MeterSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  installed_at: rfc3339(),
+  removed_at: rfc3339().optional(),
+  installed_by: import_zod.z.string().optional(),
+  removed_by: import_zod.z.string().optional(),
+  type: import_zod.z.string().optional(),
+  manufacturer: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  serial: import_zod.z.string().optional(),
+  nominal_diameter: import_zod.z.number().nonnegative().optional(),
+  max_reading: import_zod.z.number().positive().optional(),
+  notes: import_zod.z.string().optional(),
+  updated_at: rfc3339().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var ProductionEntryBaseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.string(),
+  corrects: import_zod.z.string().optional(),
+  sequence: import_zod.z.number().int().optional(),
   notes: import_zod.z.string().optional()
 });
+var MeterReadingSchema = ProductionEntryBaseSchema.extend({
+  type: import_zod.z.literal("meter_reading"),
+  datetime: rfc3339(),
+  meter_id: import_zod.z.string(),
+  reading: import_zod.z.number().nonnegative(),
+  source: import_zod.z.string().optional()
+});
+var EstimatedVolumeSchema = ProductionEntryBaseSchema.extend({
+  type: import_zod.z.literal("estimated_volume"),
+  period_start: rfc3339(),
+  period_end: rfc3339(),
+  volume: import_zod.z.number().nonnegative(),
+  method: import_zod.z.string().optional()
+});
+var PRODUCTION_TYPES = ["meter_reading", "estimated_volume"];
+var ProductionEntrySchema = import_zod.z.discriminatedUnion("type", [MeterReadingSchema, EstimatedVolumeSchema]).or(
+  ProductionEntryBaseSchema.passthrough().refine(
+    (e) => !PRODUCTION_TYPES.includes(e.type),
+    { message: "malformed production entry" }
+  )
+);
+var OperatingRegimeSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  effective_from: rfc3339(),
+  flow_rate: import_zod.z.number().nonnegative().optional(),
+  daily_operating_time: import_zod.z.number().min(0).max(24).optional(),
+  days_per_week: import_zod.z.number().int().min(1).max(7).optional(),
+  notes: import_zod.z.string().optional(),
+  updated_at: rfc3339().optional()
+});
+var PARAMETER_VOCABULARY = /^(welldot|cas|x-.+)$/;
+var ParameterSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1),
+  vocabulary: import_zod.z.string().regex(PARAMETER_VOCABULARY, "vocabulary must be welldot, cas or x-\u2026")
+});
+var TimeResolutionSchema = import_zod.z.literal("day");
+var SamplingPointSchema = import_zod.z.object({
+  type: import_zod.z.string(),
+  depth: import_zod.z.number().nonnegative().optional(),
+  depth_precision: import_zod.z.number().nonnegative().optional(),
+  from: import_zod.z.number().nonnegative().optional(),
+  to: import_zod.z.number().nonnegative().optional(),
+  device: import_zod.z.string().optional(),
+  pump_installation_id: import_zod.z.string().optional()
+}).refine(
+  (p) => !(p.depth !== void 0 && (p.from !== void 0 || p.to !== void 0)),
+  { message: "depth and from/to are mutually exclusive" }
+);
+var PurgeReadingSchema = import_zod.z.object({
+  elapsed: import_zod.z.number().nonnegative(),
+  parameter: ParameterSchema,
+  value: import_zod.z.number()
+});
+var PurgeSchema = import_zod.z.object({
+  duration: import_zod.z.number().nonnegative().optional(),
+  volume: import_zod.z.number().nonnegative().optional(),
+  flow_rate: import_zod.z.number().nonnegative().optional(),
+  stabilized: import_zod.z.boolean().optional(),
+  readings: import_zod.z.array(PurgeReadingSchema).optional()
+});
+var LaboratorySchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  accreditation: import_zod.z.string().optional(),
+  report_number: import_zod.z.string().optional(),
+  batch_id: import_zod.z.string().optional(),
+  sample_id: import_zod.z.string().optional(),
+  received_at: rfc3339().optional(),
+  received_at_resolution: TimeResolutionSchema.optional(),
+  received_temperature: import_zod.z.number().optional()
+});
+var FiltrationSchema = import_zod.z.object({
+  pore_size: import_zod.z.number().positive().optional(),
+  location: import_zod.z.enum(["field", "lab"]).optional()
+});
+var ResultValidationSchema = import_zod.z.object({
+  status: import_zod.z.enum(["unvalidated", "validated", "qualified", "rejected"]),
+  qualifier: import_zod.z.string().optional(),
+  guideline: import_zod.z.string().optional(),
+  validated_by: import_zod.z.string().optional(),
+  validated_at: rfc3339().optional()
+});
+var ResultQualifierSchema = import_zod.z.enum([
+  "<",
+  ">",
+  "not_detected",
+  "estimated"
+]);
+var WaterQualityResultSchema = import_zod.z.object({
+  parameter: ParameterSchema,
+  value: import_zod.z.number().optional(),
+  presence: import_zod.z.boolean().optional(),
+  text: import_zod.z.string().optional(),
+  qualifier: ResultQualifierSchema.optional(),
+  unit: import_zod.z.string().min(1).optional(),
+  detection_limit: import_zod.z.number().nonnegative().optional(),
+  quantification_limit: import_zod.z.number().nonnegative().optional(),
+  value_precision: import_zod.z.number().nonnegative().optional(),
+  fraction: import_zod.z.enum(["total", "dissolved", "suspended"]).optional(),
+  filtration: FiltrationSchema.optional(),
+  measured_in: import_zod.z.enum(["field", "lab"]).optional(),
+  method: import_zod.z.string().optional(),
+  analyzed_at: rfc3339().optional(),
+  analyzed_at_resolution: TimeResolutionSchema.optional(),
+  lab_flags: import_zod.z.array(import_zod.z.string()).optional(),
+  validation: ResultValidationSchema.optional(),
+  notes: import_zod.z.string().optional()
+}).superRefine((r, ctx) => {
+  const forms = [r.value, r.presence, r.text].filter(
+    (v) => v !== void 0
+  ).length;
+  if (r.qualifier === "not_detected") {
+    if (forms !== 0)
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "not_detected results carry no value form"
+      });
+  } else if (forms !== 1) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "result must have exactly one of value, presence or text"
+    });
+  } else if (r.qualifier !== void 0 && r.value === void 0) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: `qualifier ${r.qualifier} requires a numeric value`
+    });
+  }
+  const custom = r.parameter.vocabulary.startsWith("x-");
+  if (custom && r.unit === void 0)
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["unit"],
+      message: "unit is required for x- vocabularies"
+    });
+  if (!custom && r.unit !== void 0)
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["unit"],
+      message: "unit is forbidden for welldot and cas parameters"
+    });
+});
+var WaterSampleSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  datetime: rfc3339(),
+  sample_type: import_zod.z.string(),
+  parent_sample_id: import_zod.z.string().optional(),
+  sequence: import_zod.z.number().int().optional(),
+  campaign: import_zod.z.string().optional(),
+  sampling_method: import_zod.z.string().optional(),
+  sampling_point: SamplingPointSchema.optional(),
+  purge: PurgeSchema.optional(),
+  static_level_event_id: import_zod.z.string().optional(),
+  collected_by: import_zod.z.string().optional(),
+  preservation: import_zod.z.string().optional(),
+  chain_of_custody: import_zod.z.string().optional(),
+  laboratory: LaboratorySchema.optional(),
+  corrects: import_zod.z.string().optional(),
+  notes: import_zod.z.string().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional(),
+  results: import_zod.z.array(WaterQualityResultSchema).min(1)
+});
 var WellSchema = import_zod.z.object({
   version: import_zod.z.number().int(),
   "@context": import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.unknown()), import_zod.z.record(import_zod.z.unknown())]).optional(),
@@ -312,7 +753,7 @@ var WellSchema = import_zod.z.object({
   well_purpose: import_zod.z.array(import_zod.z.string()).optional(),
   name: import_zod.z.string().optional(),
   well_driller: import_zod.z.string().optional(),
-  construction_date: import_zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "construction_date must be YYYY-MM-DD").optional(),
+  construction_date: import_zod.z.string().regex(CALENDAR_DATE, "construction_date must be YYYY-MM-DD").optional(),
   obs: import_zod.z.string().optional(),
   lat: import_zod.z.number().optional(),
   lng: import_zod.z.number().optional(),
@@ -331,7 +772,14 @@ var WellSchema = import_zod.z.object({
   caves: import_zod.z.array(CaveSchema),
   hydrodynamic_events: import_zod.z.array(HydrodynamicEventSchema).optional(),
   aquifer_analysis: import_zod.z.array(AquiferAnalysisSchema).optional(),
-  history_logs: import_zod.z.array(HistoryLogEntrySchema).optional()
+  history_logs: import_zod.z.array(HistoryLogEntrySchema).optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional(),
+  pump_installations: import_zod.z.array(PumpInstallationSchema).optional(),
+  permits: import_zod.z.array(PermitSchema).optional(),
+  meters: import_zod.z.array(MeterSchema).optional(),
+  production: import_zod.z.array(ProductionEntrySchema).optional(),
+  operating_regime: import_zod.z.array(OperatingRegimeSchema).optional(),
+  water_samples: import_zod.z.array(WaterSampleSchema).optional()
 }).passthrough();
 function normalizeV1Fields(raw) {
   const out = { ...raw };
@@ -403,7 +851,7 @@ function parseWell(json) {
     }
     if (version === 1) {
       const normalized = normalizeV1Fields(raw);
-      return mergeWell(
+      return mergeParsed(
         WellSchema.parse(normalized),
         normalized
       );
@@ -413,19 +861,56 @@ function parseWell(json) {
   } else {
     raw.version = 2;
   }
-  return mergeWell(WellSchema.parse(raw), raw);
+  return mergeParsed(WellSchema.parse(raw), raw);
 }
 
 // src/utils/well.utils.ts
 var WELL_FORMAT_VERSION = 2;
 var INCHES_TO_MM = 25.4;
+var LEGACY_ROOT_KEYS = /* @__PURE__ */ new Set([
+  "lat",
+  "lng",
+  "elevation",
+  "bole_hole",
+  "constructive",
+  "geologic"
+]);
 var SECTION_KEYS = [
   "general",
   "constructive",
   "geology",
   "hydrodynamic",
-  "history"
+  "history",
+  "operation",
+  "water_quality"
 ];
+var VISIBILITY_TREE = {
+  general: ["identification", "location", "obs", "attachments"],
+  constructive: [
+    "bore_hole",
+    "surface_case",
+    "well_case",
+    "reduction",
+    "well_screen",
+    "hole_fill",
+    "centralizers",
+    "cement_pad"
+  ],
+  geology: ["lithology", "fractures", "caves"],
+  hydrodynamic: ["hydrodynamic_events", "aquifer_analysis"],
+  history: [],
+  operation: [
+    "pump_installations",
+    "meters",
+    "operating_regime",
+    "production",
+    "permits"
+  ],
+  water_quality: []
+};
+var VISIBILITY_LEAF_KEYS = SECTION_KEYS.flatMap(
+  (section) => VISIBILITY_TREE[section].length ? VISIBILITY_TREE[section] : [section]
+);
 var EMPTY_WELL = {
   version: 2,
   bore_hole: [],
@@ -572,6 +1057,27 @@ function decodeV2Well(raw) {
     },
     ...raw.history_logs !== void 0 && {
       history_logs: raw.history_logs
+    },
+    ...raw.attachments !== void 0 && {
+      attachments: raw.attachments
+    },
+    ...raw.pump_installations !== void 0 && {
+      pump_installations: raw.pump_installations
+    },
+    ...raw.permits !== void 0 && {
+      permits: raw.permits
+    },
+    ...raw.meters !== void 0 && {
+      meters: raw.meters
+    },
+    ...raw.production !== void 0 && {
+      production: raw.production
+    },
+    ...raw.operating_regime !== void 0 && {
+      operating_regime: raw.operating_regime
+    },
+    ...raw.water_samples !== void 0 && {
+      water_samples: raw.water_samples
     }
   };
   return mergeWell(decoded, raw);
@@ -613,6 +1119,11 @@ function normalizeGeologic(raw) {
     caves: raw.caves ?? []
   };
 }
+function unknownRootKeys(well) {
+  return Object.keys(well).filter(
+    (key) => !(key in WellSchema.shape) && !LEGACY_ROOT_KEYS.has(key)
+  );
+}
 function serializeWell(well) {
   const payload = {
     version: WELL_FORMAT_VERSION,
@@ -650,8 +1161,25 @@ function serializeWell(well) {
     ...well.aquifer_analysis !== void 0 && {
       aquifer_analysis: well.aquifer_analysis
     },
-    ...well.history_logs !== void 0 && { history_logs: well.history_logs }
+    ...well.history_logs !== void 0 && { history_logs: well.history_logs },
+    ...well.attachments !== void 0 && { attachments: well.attachments },
+    ...well.pump_installations !== void 0 && {
+      pump_installations: well.pump_installations
+    },
+    ...well.permits !== void 0 && { permits: well.permits },
+    ...well.meters !== void 0 && { meters: well.meters },
+    ...well.production !== void 0 && { production: well.production },
+    ...well.operating_regime !== void 0 && {
+      operating_regime: well.operating_regime
+    },
+    ...well.water_samples !== void 0 && {
+      water_samples: well.water_samples
+    }
   };
+  for (const key of unknownRootKeys(well)) {
+    const value = well[key];
+    if (value !== void 0) payload[key] = value;
+  }
   return JSON.stringify(payload);
 }
 function isWellEmpty(well) {
@@ -660,43 +1188,68 @@ function isWellEmpty(well) {
   if (raw.constructive || raw.geologic) return false;
   return well.lithology?.length === 0 && well.fractures?.length === 0 && well.caves?.length === 0 && well.bore_hole?.length === 0 && well.hole_fill?.length === 0 && well.well_case?.length === 0 && well.well_screen?.length === 0;
 }
+function isFilled(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim() !== "";
+  if (typeof value === "number") return value !== 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.values(value).some(isFilled);
+  return true;
+}
+var NON_DATA_ROOT_KEYS = /* @__PURE__ */ new Set(["version", "$schema", "@context"]);
+function hasWellData(well) {
+  if (!well) return false;
+  if (!isWellEmpty(well)) return true;
+  return Object.entries(well).some(
+    ([key, value]) => !NON_DATA_ROOT_KEYS.has(key) && isFilled(value)
+  );
+}
 function redactWell(well, visibility) {
+  const v = visibility;
   const redacted = { ...well };
-  if (!visibility.general) {
+  const sectionOf = (field) => SECTION_KEYS.find((s) => VISIBILITY_TREE[s].includes(field));
+  const hidden = (key) => v[key] === false || !SECTION_KEYS.includes(key) && v[sectionOf(key)] === false;
+  const sectionHidden = (section) => v[section] === false || VISIBILITY_TREE[section].length > 0 && VISIBILITY_TREE[section].every((f) => v[f] === false);
+  if (hidden("identification")) {
     delete redacted.well_id;
-    delete redacted.location;
     delete redacted.well_type;
     delete redacted.well_purpose;
     delete redacted.name;
     delete redacted.well_driller;
     delete redacted.construction_date;
-    delete redacted.obs;
+  }
+  if (hidden("location")) {
+    delete redacted.location;
     delete redacted.lat;
     delete redacted.lng;
     delete redacted.elevation;
   }
-  if (!visibility.constructive) {
-    redacted.bore_hole = [];
-    redacted.well_case = [];
-    redacted.reduction = [];
-    redacted.well_screen = [];
-    redacted.surface_case = [];
-    redacted.hole_fill = [];
-    delete redacted.centralizers;
-    delete redacted.cement_pad;
-    delete redacted.well_depth;
-  }
-  if (!visibility.geology) {
-    redacted.lithology = [];
-    redacted.fractures = [];
-    redacted.caves = [];
-  }
-  if (!visibility.hydrodynamic) {
-    redacted.hydrodynamic_events = [];
-    redacted.aquifer_analysis = [];
-  }
-  if (!visibility.history) {
-    redacted.history_logs = [];
+  if (hidden("obs")) delete redacted.obs;
+  if (hidden("attachments")) delete redacted.attachments;
+  if (hidden("bore_hole")) redacted.bore_hole = [];
+  if (hidden("surface_case")) redacted.surface_case = [];
+  if (hidden("well_case")) redacted.well_case = [];
+  if (hidden("reduction")) redacted.reduction = [];
+  if (hidden("well_screen")) redacted.well_screen = [];
+  if (hidden("hole_fill")) redacted.hole_fill = [];
+  if (hidden("centralizers")) delete redacted.centralizers;
+  if (hidden("cement_pad")) delete redacted.cement_pad;
+  if (sectionHidden("constructive")) delete redacted.well_depth;
+  if (hidden("lithology")) redacted.lithology = [];
+  if (hidden("fractures")) redacted.fractures = [];
+  if (hidden("caves")) redacted.caves = [];
+  if (hidden("hydrodynamic_events")) redacted.hydrodynamic_events = [];
+  if (hidden("aquifer_analysis")) redacted.aquifer_analysis = [];
+  if (hidden("history")) redacted.history_logs = [];
+  if (hidden("pump_installations")) delete redacted.pump_installations;
+  if (hidden("meters")) delete redacted.meters;
+  if (hidden("operating_regime")) delete redacted.operating_regime;
+  if (hidden("production")) delete redacted.production;
+  if (hidden("permits")) delete redacted.permits;
+  if (hidden("water_quality")) delete redacted.water_samples;
+  if (Object.values(v).some((shown) => shown === false)) {
+    for (const key of unknownRootKeys(redacted))
+      delete redacted[key];
   }
   return redacted;
 }
@@ -1051,6 +1604,1521 @@ var FGDC_TEXTURES_OPTIONS = [
   { code: 733, label: "Ore" }
 ];
 
+// src/vocab/waterQuality.limits.ts
+var NEPHELOMETRIC_TURBIDITY_CODES = [
+  "turbidity",
+  "turbidity_ntu",
+  "turbidity_fnu"
+];
+var WHO_GDWQ_2022 = {
+  id: "who_gdwq_2022",
+  name: "WHO Guidelines for Drinking-water Quality (2022)",
+  jurisdiction: "INT",
+  source: "WHO, Guidelines for drinking-water quality: 4th edition incorporating the first and second addenda, 2022",
+  limits: [
+    { code: "antimony", max: 0.02, basis: "health" },
+    { code: "arsenic", max: 0.01, basis: "health", note: "provisional" },
+    { code: "barium", max: 1.3, basis: "health" },
+    { code: "boron", max: 2.4, basis: "health" },
+    { code: "cadmium", max: 3e-3, basis: "health" },
+    { code: "chromium", max: 0.05, basis: "health", note: "provisional" },
+    { code: "copper", max: 2, basis: "health" },
+    { code: "fluoride", max: 1.5, basis: "health" },
+    { code: "lead", max: 0.01, basis: "health", note: "provisional" },
+    { code: "manganese", max: 0.08, basis: "health", note: "provisional" },
+    { code: "mercury", max: 6e-3, basis: "health", note: "inorganic mercury" },
+    { code: "nickel", max: 0.07, basis: "health" },
+    { code: "nitrate_as_no3", max: 50, basis: "health" },
+    { code: "nitrite_as_no2", max: 3, basis: "health" },
+    { code: "selenium", max: 0.04, basis: "health", note: "provisional" },
+    { code: "uranium", max: 0.03, basis: "health", note: "provisional" },
+    { code: "e_coli", presence_allowed: false, basis: "health" },
+    {
+      code: "thermotolerant_coliforms",
+      presence_allowed: false,
+      basis: "health"
+    },
+    { code: "gross_alpha", max: 0.5, basis: "health", note: "screening level" },
+    { code: "gross_beta", max: 1, basis: "health", note: "screening level" }
+  ]
+};
+var BR_GM_MS_888_2021 = {
+  id: "br_gm_ms_888_2021",
+  name: "Brasil \u2014 Portaria GM/MS 888/2021",
+  jurisdiction: "BR",
+  source: "Minist\xE9rio da Sa\xFAde, Portaria GM/MS n\xBA 888, de 4 de maio de 2021",
+  limits: [
+    // Inorganic substances (health)
+    { code: "antimony", max: 6e-3, basis: "health" },
+    { code: "arsenic", max: 0.01, basis: "health" },
+    { code: "barium", max: 0.7, basis: "health" },
+    { code: "cadmium", max: 3e-3, basis: "health" },
+    { code: "lead", max: 0.01, basis: "health" },
+    { code: "cyanide_total_as_cn", max: 0.07, basis: "health" },
+    { code: "copper", max: 2, basis: "health" },
+    { code: "chromium", max: 0.05, basis: "health" },
+    { code: "fluoride", max: 1.5, basis: "health" },
+    { code: "mercury", max: 1e-3, basis: "health" },
+    { code: "nickel", max: 0.07, basis: "health" },
+    { code: "nitrate_as_n", max: 10, basis: "health" },
+    { code: "nitrite_as_n", max: 1, basis: "health" },
+    { code: "selenium", max: 0.04, basis: "health" },
+    { code: "uranium", max: 0.03, basis: "health" },
+    // Organoleptic standard
+    { code: "aluminum", max: 0.2, basis: "aesthetic" },
+    { code: "ammonia_as_nh3", max: 1.2, basis: "aesthetic" },
+    { code: "chloride", max: 250, basis: "aesthetic" },
+    { code: "apparent_color", max: 15, basis: "aesthetic" },
+    { code: "hardness_total_as_caco3", max: 300, basis: "aesthetic" },
+    { code: "iron", max: 0.3, basis: "aesthetic" },
+    { code: "manganese", max: 0.1, basis: "aesthetic" },
+    { code: "sodium", max: 200, basis: "aesthetic" },
+    { code: "total_dissolved_solids", max: 500, basis: "aesthetic" },
+    { code: "sulfate", max: 250, basis: "aesthetic" },
+    {
+      code: "turbidity",
+      max: 5,
+      basis: "aesthetic",
+      note: "organoleptic standard (uT)"
+    },
+    // Operational
+    {
+      code: "ph",
+      min: 6,
+      max: 9,
+      basis: "operational",
+      note: "recommended range"
+    },
+    {
+      code: "free_chlorine",
+      min: 0.2,
+      max: 5,
+      basis: "operational",
+      note: "residual in the distribution system"
+    },
+    // Microbiological
+    { code: "e_coli", presence_allowed: false, basis: "health" },
+    {
+      code: "total_coliforms",
+      presence_allowed: false,
+      basis: "indicator",
+      note: "tolerances apply by system size and sampling point"
+    },
+    // Radioactivity
+    { code: "gross_alpha", max: 0.5, basis: "health", note: "screening level" },
+    { code: "gross_beta", max: 1, basis: "health", note: "screening level" },
+    { code: "radium_226", max: 1, basis: "health" },
+    { code: "radium_228", max: 0.1, basis: "health" }
+  ]
+};
+var EU_2020_2184 = {
+  id: "eu_2020_2184",
+  name: "EU Drinking Water Directive 2020/2184",
+  jurisdiction: "EU",
+  source: "Directive (EU) 2020/2184 of the European Parliament and of the Council, Annex I",
+  limits: [
+    // Part A — microbiological
+    { code: "e_coli", presence_allowed: false, basis: "health" },
+    // Part B — chemical
+    { code: "antimony", max: 0.01, basis: "health" },
+    { code: "arsenic", max: 0.01, basis: "health" },
+    {
+      code: "boron",
+      max: 1.5,
+      basis: "health",
+      note: "2.4 mg/L where desalinated water is the predominant source"
+    },
+    { code: "cadmium", max: 5e-3, basis: "health" },
+    {
+      code: "chromium",
+      max: 0.05,
+      basis: "health",
+      note: "0.025 mg/L from 12 January 2036"
+    },
+    { code: "copper", max: 2, basis: "health" },
+    { code: "cyanide_total_as_cn", max: 0.05, basis: "health" },
+    { code: "fluoride", max: 1.5, basis: "health" },
+    {
+      code: "lead",
+      max: 0.01,
+      basis: "health",
+      note: "0.005 mg/L from 12 January 2036"
+    },
+    { code: "mercury", max: 1e-3, basis: "health" },
+    { code: "nickel", max: 0.02, basis: "health" },
+    { code: "nitrate_as_no3", max: 50, basis: "health" },
+    { code: "nitrite_as_no2", max: 0.5, basis: "health", note: "at the tap" },
+    { code: "selenium", max: 0.02, basis: "health" },
+    { code: "uranium", max: 0.03, basis: "health" },
+    // Part C — indicator parameters
+    { code: "aluminum", max: 0.2, basis: "indicator" },
+    { code: "chloride", max: 250, basis: "indicator" },
+    {
+      code: "specific_conductance",
+      max: 2500,
+      basis: "indicator",
+      note: "directive value is at 20 \xB0C"
+    },
+    { code: "ph", min: 6.5, max: 9.5, basis: "indicator" },
+    { code: "iron", max: 0.2, basis: "indicator" },
+    { code: "manganese", max: 0.05, basis: "indicator" },
+    { code: "sodium", max: 200, basis: "indicator" },
+    { code: "sulfate", max: 250, basis: "indicator" },
+    { code: "total_coliforms", presence_allowed: false, basis: "indicator" }
+  ]
+};
+var WATER_QUALITY_LIMIT_SETS = [
+  WHO_GDWQ_2022,
+  BR_GM_MS_888_2021,
+  EU_2020_2184
+];
+function getLimitSet(id) {
+  return WATER_QUALITY_LIMIT_SETS.find((s) => s.id === id);
+}
+
+// src/utils/language.utils.ts
+function parseLanguageTextJson(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const entries = Object.entries(parsed).filter(
+    (entry) => typeof entry[1] === "string" && entry[1].trim() !== ""
+  );
+  return Object.fromEntries(entries);
+}
+function resolveLanguageText(text, locale, fallback = "en") {
+  if (text == null) return "";
+  const labels = typeof text === "string" ? parseLanguageTextJson(text) : text;
+  if (labels === void 0) return text;
+  const base = locale.split("-")[0];
+  const usable = (key) => {
+    const value = labels[key];
+    return typeof value === "string" && value.trim() !== "" ? value : void 0;
+  };
+  return usable(locale) ?? usable(base) ?? usable(fallback) ?? Object.keys(labels).map(usable).find((v) => v !== void 0) ?? "";
+}
+
+// src/vocab/waterQuality.vocab.ts
+var WATER_QUALITY_VOCABULARY_VERSION = "1.0.0";
+var WATER_QUALITY_UNITS = {
+  mg_l: { symbol: "mg/L", ucum: "mg/L" },
+  us_cm: { symbol: "\xB5S/cm", ucum: "uS/cm" },
+  celsius: { symbol: "\xB0C", ucum: "Cel" },
+  mv: { symbol: "mV", ucum: "mV" },
+  ph: { symbol: "", ucum: "[pH]" },
+  ftu: { symbol: "FTU" },
+  ntu: { symbol: "NTU" },
+  fnu: { symbol: "FNU" },
+  fau: { symbol: "FAU" },
+  hazen: { symbol: "uH" },
+  mpn_100ml: { symbol: "MPN/100 mL", ucum: "{MPN}/(100.mL)" },
+  cfu_100ml: { symbol: "CFU/100 mL", ucum: "{CFU}/(100.mL)" },
+  cfu_ml: { symbol: "CFU/mL", ucum: "{CFU}/mL" },
+  bq_l: { symbol: "Bq/L", ucum: "Bq/L" },
+  none: { symbol: "" }
+};
+var U = WATER_QUALITY_UNITS;
+function defineParameter(code, group, label, pt, unit, extra = {}) {
+  return {
+    code,
+    group,
+    label,
+    labels: { pt },
+    unit,
+    form: extra.form ?? "value",
+    ...extra.cas !== void 0 && { cas: extra.cas },
+    ...extra.molar_mass !== void 0 && { molar_mass: extra.molar_mass },
+    ...extra.charge !== void 0 && { charge: extra.charge }
+  };
+}
+var WATER_QUALITY_PARAMETERS = [
+  // Physical / field
+  defineParameter(
+    "temperature",
+    "physical",
+    "Temperature",
+    "Temperatura",
+    U.celsius
+  ),
+  defineParameter("ph", "physical", "pH", "pH", U.ph),
+  defineParameter(
+    "specific_conductance",
+    "physical",
+    "Specific conductance at 25 \xB0C",
+    "Condutividade el\xE9trica a 25 \xB0C",
+    U.us_cm
+  ),
+  defineParameter(
+    "conductivity_uncompensated",
+    "physical",
+    "Electrical conductivity, uncompensated",
+    "Condutividade sem compensa\xE7\xE3o",
+    U.us_cm
+  ),
+  defineParameter(
+    "dissolved_oxygen",
+    "physical",
+    "Dissolved oxygen",
+    "Oxig\xEAnio dissolvido",
+    U.mg_l
+  ),
+  defineParameter(
+    "orp",
+    "physical",
+    "Oxidation-reduction potential vs. reference electrode",
+    "Potencial redox vs. eletrodo de refer\xEAncia",
+    U.mv
+  ),
+  defineParameter(
+    "eh",
+    "physical",
+    "Redox potential vs. SHE",
+    "Potencial redox corrigido vs. EPH",
+    U.mv
+  ),
+  defineParameter(
+    "turbidity",
+    "physical",
+    "Turbidity, formazin, method unspecified",
+    "Turbidez, formazina sem m\xE9todo identificado",
+    U.ftu
+  ),
+  defineParameter(
+    "turbidity_ntu",
+    "physical",
+    "Turbidity, nephelometric white light",
+    "Turbidez nefelom\xE9trica, luz branca",
+    U.ntu
+  ),
+  defineParameter(
+    "turbidity_fnu",
+    "physical",
+    "Turbidity, nephelometric infrared (ISO 7027)",
+    "Turbidez nefelom\xE9trica, infravermelho",
+    U.fnu
+  ),
+  defineParameter(
+    "turbidity_fau",
+    "physical",
+    "Turbidity, attenuation (ISO 7027)",
+    "Turbidez por atenua\xE7\xE3o",
+    U.fau
+  ),
+  defineParameter(
+    "apparent_color",
+    "physical",
+    "Apparent color",
+    "Cor aparente",
+    U.hazen
+  ),
+  defineParameter(
+    "true_color",
+    "physical",
+    "True color",
+    "Cor verdadeira",
+    U.hazen
+  ),
+  defineParameter("odor", "physical", "Odor", "Odor", U.none, { form: "text" }),
+  defineParameter("taste", "physical", "Taste", "Gosto", U.none, {
+    form: "text"
+  }),
+  defineParameter(
+    "total_dissolved_solids",
+    "physical",
+    "Total dissolved solids",
+    "S\xF3lidos totais dissolvidos",
+    U.mg_l
+  ),
+  defineParameter(
+    "total_suspended_solids",
+    "physical",
+    "Total suspended solids",
+    "S\xF3lidos suspensos totais",
+    U.mg_l
+  ),
+  defineParameter(
+    "total_solids",
+    "physical",
+    "Total solids",
+    "S\xF3lidos totais",
+    U.mg_l
+  ),
+  defineParameter(
+    "free_co2",
+    "physical",
+    "Free carbon dioxide",
+    "G\xE1s carb\xF4nico livre",
+    U.mg_l
+  ),
+  // Aggregate (expressed as CaCO₃: 100.087 g/mol, divalent → 50.04 mg/meq)
+  defineParameter(
+    "alkalinity_total_as_caco3",
+    "aggregate",
+    "Total alkalinity as CaCO\u2083",
+    "Alcalinidade total como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: -2 }
+  ),
+  defineParameter(
+    "alkalinity_bicarbonate_as_caco3",
+    "aggregate",
+    "Bicarbonate alkalinity as CaCO\u2083",
+    "Alcalinidade de bicarbonatos como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: -2 }
+  ),
+  defineParameter(
+    "alkalinity_carbonate_as_caco3",
+    "aggregate",
+    "Carbonate alkalinity as CaCO\u2083",
+    "Alcalinidade de carbonatos como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: -2 }
+  ),
+  defineParameter(
+    "alkalinity_hydroxide_as_caco3",
+    "aggregate",
+    "Hydroxide alkalinity as CaCO\u2083",
+    "Alcalinidade de hidr\xF3xidos como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: -2 }
+  ),
+  defineParameter(
+    "acidity_total_as_caco3",
+    "aggregate",
+    "Total acidity as CaCO\u2083",
+    "Acidez total como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: 2 }
+  ),
+  defineParameter(
+    "hardness_total_as_caco3",
+    "aggregate",
+    "Total hardness as CaCO\u2083",
+    "Dureza total como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: 2 }
+  ),
+  defineParameter(
+    "hardness_calcium_as_caco3",
+    "aggregate",
+    "Calcium hardness as CaCO\u2083",
+    "Dureza de c\xE1lcio como CaCO\u2083",
+    U.mg_l,
+    { molar_mass: 100.087, charge: 2 }
+  ),
+  // Major ions
+  defineParameter("calcium", "major_ion", "Calcium", "C\xE1lcio", U.mg_l, {
+    cas: "7440-70-2",
+    molar_mass: 40.078,
+    charge: 2
+  }),
+  defineParameter("magnesium", "major_ion", "Magnesium", "Magn\xE9sio", U.mg_l, {
+    cas: "7439-95-4",
+    molar_mass: 24.305,
+    charge: 2
+  }),
+  defineParameter("sodium", "major_ion", "Sodium", "S\xF3dio", U.mg_l, {
+    cas: "7440-23-5",
+    molar_mass: 22.99,
+    charge: 1
+  }),
+  defineParameter("potassium", "major_ion", "Potassium", "Pot\xE1ssio", U.mg_l, {
+    cas: "7440-09-7",
+    molar_mass: 39.098,
+    charge: 1
+  }),
+  defineParameter(
+    "bicarbonate",
+    "major_ion",
+    "Bicarbonate as HCO\u2083\u207B",
+    "Bicarbonato como HCO\u2083\u207B",
+    U.mg_l,
+    { cas: "71-52-3", molar_mass: 61.017, charge: -1 }
+  ),
+  defineParameter(
+    "carbonate",
+    "major_ion",
+    "Carbonate as CO\u2083\xB2\u207B",
+    "Carbonato como CO\u2083\xB2\u207B",
+    U.mg_l,
+    { cas: "3812-32-6", molar_mass: 60.009, charge: -2 }
+  ),
+  defineParameter("chloride", "major_ion", "Chloride", "Cloreto", U.mg_l, {
+    cas: "16887-00-6",
+    molar_mass: 35.453,
+    charge: -1
+  }),
+  defineParameter("sulfate", "major_ion", "Sulfate", "Sulfato", U.mg_l, {
+    cas: "14808-79-8",
+    molar_mass: 96.06,
+    charge: -2
+  }),
+  defineParameter("fluoride", "major_ion", "Fluoride", "Fluoreto", U.mg_l, {
+    cas: "16984-48-8",
+    molar_mass: 18.998,
+    charge: -1
+  }),
+  defineParameter(
+    "silica_as_sio2",
+    "major_ion",
+    "Silica as SiO\u2082",
+    "S\xEDlica como SiO\u2082",
+    U.mg_l,
+    { cas: "7631-86-9" }
+  ),
+  // Nutrients
+  defineParameter(
+    "nitrate_as_n",
+    "nutrient",
+    "Nitrate as N",
+    "Nitrato como N",
+    U.mg_l,
+    {
+      molar_mass: 14.007,
+      charge: -1
+    }
+  ),
+  defineParameter(
+    "nitrate_as_no3",
+    "nutrient",
+    "Nitrate as NO\u2083\u207B",
+    "Nitrato como NO\u2083\u207B",
+    U.mg_l,
+    { cas: "14797-55-8", molar_mass: 62.004, charge: -1 }
+  ),
+  defineParameter(
+    "nitrite_as_n",
+    "nutrient",
+    "Nitrite as N",
+    "Nitrito como N",
+    U.mg_l,
+    {
+      molar_mass: 14.007,
+      charge: -1
+    }
+  ),
+  defineParameter(
+    "nitrite_as_no2",
+    "nutrient",
+    "Nitrite as NO\u2082\u207B",
+    "Nitrito como NO\u2082\u207B",
+    U.mg_l,
+    { cas: "14797-65-0", molar_mass: 46.005, charge: -1 }
+  ),
+  defineParameter(
+    "ammonia_as_n",
+    "nutrient",
+    "Ammonia nitrogen as N",
+    "Nitrog\xEAnio amoniacal como N",
+    U.mg_l,
+    { molar_mass: 14.007, charge: 1 }
+  ),
+  defineParameter(
+    "ammonia_as_nh3",
+    "nutrient",
+    "Ammonia as NH\u2083",
+    "Am\xF4nia como NH\u2083",
+    U.mg_l,
+    {
+      cas: "7664-41-7"
+    }
+  ),
+  defineParameter(
+    "kjeldahl_nitrogen_as_n",
+    "nutrient",
+    "Total Kjeldahl nitrogen as N",
+    "Nitrog\xEAnio Kjeldahl total como N",
+    U.mg_l
+  ),
+  defineParameter(
+    "phosphorus_total_as_p",
+    "nutrient",
+    "Total phosphorus as P",
+    "F\xF3sforo total como P",
+    U.mg_l
+  ),
+  defineParameter(
+    "orthophosphate_as_po4",
+    "nutrient",
+    "Orthophosphate as PO\u2084\xB3\u207B",
+    "Ortofosfato como PO\u2084\xB3\u207B",
+    U.mg_l,
+    { molar_mass: 94.971, charge: -3 }
+  ),
+  // Organic
+  defineParameter(
+    "total_organic_carbon",
+    "organic",
+    "Total organic carbon",
+    "Carbono org\xE2nico total",
+    U.mg_l
+  ),
+  defineParameter(
+    "cod",
+    "organic",
+    "Chemical oxygen demand",
+    "Demanda qu\xEDmica de oxig\xEAnio (DQO)",
+    U.mg_l
+  ),
+  defineParameter(
+    "bod5",
+    "organic",
+    "Biochemical oxygen demand, 5-day",
+    "Demanda bioqu\xEDmica de oxig\xEAnio (DBO\u2085)",
+    U.mg_l
+  ),
+  defineParameter(
+    "total_petroleum_hydrocarbons",
+    "organic",
+    "Total petroleum hydrocarbons (range per method)",
+    "Hidrocarbonetos totais de petr\xF3leo",
+    U.mg_l
+  ),
+  defineParameter(
+    "oil_and_grease",
+    "organic",
+    "Oil and grease",
+    "\xD3leos e graxas",
+    U.mg_l
+  ),
+  // Disinfection
+  defineParameter(
+    "free_chlorine",
+    "disinfection",
+    "Free chlorine residual",
+    "Cloro residual livre",
+    U.mg_l
+  ),
+  defineParameter(
+    "total_chlorine",
+    "disinfection",
+    "Total chlorine residual",
+    "Cloro residual total",
+    U.mg_l
+  ),
+  // Mining and redox
+  defineParameter(
+    "ferrous_iron",
+    "mining_redox",
+    "Ferrous iron (Fe\xB2\u207A)",
+    "Ferro ferroso (Fe\xB2\u207A)",
+    U.mg_l
+  ),
+  defineParameter(
+    "chromium_hexavalent",
+    "mining_redox",
+    "Hexavalent chromium",
+    "Cromo hexavalente",
+    U.mg_l,
+    { cas: "18540-29-9" }
+  ),
+  defineParameter(
+    "cyanide_total_as_cn",
+    "mining_redox",
+    "Total cyanide as CN\u207B",
+    "Cianeto total como CN\u207B",
+    U.mg_l
+  ),
+  defineParameter(
+    "cyanide_wad_as_cn",
+    "mining_redox",
+    "Weak acid dissociable cyanide as CN\u207B",
+    "Cianeto WAD como CN\u207B",
+    U.mg_l
+  ),
+  defineParameter(
+    "cyanide_free_as_cn",
+    "mining_redox",
+    "Free cyanide as CN\u207B",
+    "Cianeto livre como CN\u207B",
+    U.mg_l
+  ),
+  defineParameter(
+    "thiocyanate",
+    "mining_redox",
+    "Thiocyanate",
+    "Tiocianato",
+    U.mg_l,
+    {
+      cas: "302-04-5"
+    }
+  ),
+  defineParameter(
+    "sulfide_total_as_s",
+    "mining_redox",
+    "Total sulfide as S",
+    "Sulfeto total como S",
+    U.mg_l
+  ),
+  // Metals / trace
+  defineParameter("iron", "metal", "Iron", "Ferro", U.mg_l, {
+    cas: "7439-89-6",
+    molar_mass: 55.845,
+    charge: 2
+  }),
+  defineParameter("manganese", "metal", "Manganese", "Mangan\xEAs", U.mg_l, {
+    cas: "7439-96-5",
+    molar_mass: 54.938,
+    charge: 2
+  }),
+  defineParameter("aluminum", "metal", "Aluminium", "Alum\xEDnio", U.mg_l, {
+    cas: "7429-90-5"
+  }),
+  defineParameter("antimony", "metal", "Antimony", "Antim\xF4nio", U.mg_l, {
+    cas: "7440-36-0"
+  }),
+  defineParameter("arsenic", "metal", "Arsenic", "Ars\xEAnio", U.mg_l, {
+    cas: "7440-38-2"
+  }),
+  defineParameter("barium", "metal", "Barium", "B\xE1rio", U.mg_l, {
+    cas: "7440-39-3"
+  }),
+  defineParameter("beryllium", "metal", "Beryllium", "Ber\xEDlio", U.mg_l, {
+    cas: "7440-41-7"
+  }),
+  defineParameter("boron", "metal", "Boron", "Boro", U.mg_l, {
+    cas: "7440-42-8"
+  }),
+  defineParameter("cadmium", "metal", "Cadmium", "C\xE1dmio", U.mg_l, {
+    cas: "7440-43-9"
+  }),
+  defineParameter(
+    "chromium",
+    "metal",
+    "Chromium, total",
+    "Cromo total",
+    U.mg_l,
+    {
+      cas: "7440-47-3"
+    }
+  ),
+  defineParameter("cobalt", "metal", "Cobalt", "Cobalto", U.mg_l, {
+    cas: "7440-48-4"
+  }),
+  defineParameter("copper", "metal", "Copper", "Cobre", U.mg_l, {
+    cas: "7440-50-8"
+  }),
+  defineParameter("lead", "metal", "Lead", "Chumbo", U.mg_l, {
+    cas: "7439-92-1"
+  }),
+  defineParameter("lithium", "metal", "Lithium", "L\xEDtio", U.mg_l, {
+    cas: "7439-93-2",
+    molar_mass: 6.94,
+    charge: 1
+  }),
+  defineParameter("mercury", "metal", "Mercury", "Merc\xFArio", U.mg_l, {
+    cas: "7439-97-6"
+  }),
+  defineParameter("molybdenum", "metal", "Molybdenum", "Molibd\xEAnio", U.mg_l, {
+    cas: "7439-98-7"
+  }),
+  defineParameter("nickel", "metal", "Nickel", "N\xEDquel", U.mg_l, {
+    cas: "7440-02-0"
+  }),
+  defineParameter("selenium", "metal", "Selenium", "Sel\xEAnio", U.mg_l, {
+    cas: "7782-49-2"
+  }),
+  defineParameter("silver", "metal", "Silver", "Prata", U.mg_l, {
+    cas: "7440-22-4"
+  }),
+  defineParameter("strontium", "metal", "Strontium", "Estr\xF4ncio", U.mg_l, {
+    cas: "7440-24-6",
+    molar_mass: 87.62,
+    charge: 2
+  }),
+  defineParameter("thallium", "metal", "Thallium", "T\xE1lio", U.mg_l, {
+    cas: "7440-28-0"
+  }),
+  defineParameter("uranium", "metal", "Uranium", "Ur\xE2nio", U.mg_l, {
+    cas: "7440-61-1"
+  }),
+  defineParameter("vanadium", "metal", "Vanadium", "Van\xE1dio", U.mg_l, {
+    cas: "7440-62-2"
+  }),
+  defineParameter("zinc", "metal", "Zinc", "Zinco", U.mg_l, {
+    cas: "7440-66-6"
+  }),
+  // Microbiology
+  defineParameter(
+    "total_coliforms",
+    "microbiology",
+    "Total coliforms in 100 mL",
+    "Coliformes totais em 100 mL",
+    U.none,
+    { form: "presence" }
+  ),
+  defineParameter(
+    "total_coliforms_mpn",
+    "microbiology",
+    "Total coliforms, count",
+    "Coliformes totais, contagem",
+    U.mpn_100ml
+  ),
+  defineParameter(
+    "total_coliforms_cfu",
+    "microbiology",
+    "Total coliforms, count",
+    "Coliformes totais, contagem",
+    U.cfu_100ml
+  ),
+  defineParameter(
+    "e_coli",
+    "microbiology",
+    "E. coli in 100 mL",
+    "E. coli em 100 mL",
+    U.none,
+    { form: "presence" }
+  ),
+  defineParameter(
+    "e_coli_mpn",
+    "microbiology",
+    "E. coli, count",
+    "E. coli, contagem",
+    U.mpn_100ml
+  ),
+  defineParameter(
+    "e_coli_cfu",
+    "microbiology",
+    "E. coli, count",
+    "E. coli, contagem",
+    U.cfu_100ml
+  ),
+  defineParameter(
+    "thermotolerant_coliforms",
+    "microbiology",
+    "Thermotolerant coliforms in 100 mL",
+    "Coliformes termotolerantes em 100 mL",
+    U.none,
+    { form: "presence" }
+  ),
+  defineParameter(
+    "thermotolerant_coliforms_mpn",
+    "microbiology",
+    "Thermotolerant coliforms, count",
+    "Coliformes termotolerantes, contagem",
+    U.mpn_100ml
+  ),
+  defineParameter(
+    "thermotolerant_coliforms_cfu",
+    "microbiology",
+    "Thermotolerant coliforms, count",
+    "Coliformes termotolerantes, contagem",
+    U.cfu_100ml
+  ),
+  defineParameter(
+    "heterotrophic_plate_count",
+    "microbiology",
+    "Heterotrophic plate count",
+    "Bact\xE9rias heterotr\xF3ficas",
+    U.cfu_ml
+  ),
+  // Radioactivity (Bq/L even where a CAS exists)
+  defineParameter(
+    "gross_alpha",
+    "radioactivity",
+    "Gross alpha activity",
+    "Atividade alfa total",
+    U.bq_l
+  ),
+  defineParameter(
+    "gross_beta",
+    "radioactivity",
+    "Gross beta activity",
+    "Atividade beta total",
+    U.bq_l
+  ),
+  defineParameter(
+    "radium_226",
+    "radioactivity",
+    "Radium-226",
+    "R\xE1dio-226",
+    U.bq_l,
+    {
+      cas: "13982-63-3"
+    }
+  ),
+  defineParameter(
+    "radium_228",
+    "radioactivity",
+    "Radium-228",
+    "R\xE1dio-228",
+    U.bq_l,
+    {
+      cas: "15262-20-1"
+    }
+  ),
+  defineParameter(
+    "radon_222",
+    "radioactivity",
+    "Radon-222",
+    "Rad\xF4nio-222",
+    U.bq_l,
+    {
+      cas: "14859-67-7"
+    }
+  )
+];
+var BY_CODE = new Map(WATER_QUALITY_PARAMETERS.map((d) => [d.code, d]));
+var BY_CAS = new Map(
+  WATER_QUALITY_PARAMETERS.filter((d) => d.cas).map((d) => [d.cas, d])
+);
+function getParameterDefinition(parameter) {
+  if (parameter.vocabulary === "welldot") return BY_CODE.get(parameter.code);
+  if (parameter.vocabulary === "cas") return BY_CAS.get(parameter.code);
+  return void 0;
+}
+function getParameterLabel(parameter, locale) {
+  const def = getParameterDefinition(parameter);
+  if (!def) return parameter.code;
+  return resolveLanguageText({ ...def.labels, en: def.label }, locale, "en");
+}
+function parameterKey(parameter) {
+  const def = getParameterDefinition(parameter);
+  if (def) return def.code;
+  return `${parameter.vocabulary}:${parameter.code}`;
+}
+function isKnownParameter(parameter) {
+  if (parameter.vocabulary !== "welldot") return true;
+  return BY_CODE.has(parameter.code);
+}
+
+// src/vocab/attachment.vocab.ts
+var DOCUMENT_TYPES = [
+  {
+    value: "drilling_report",
+    label: { en: "Drilling report", pt: "Relat\xF3rio de perfura\xE7\xE3o" }
+  },
+  {
+    value: "as_built_drawing",
+    label: { en: "As-built drawing", pt: "Perfil construtivo as-built" }
+  },
+  {
+    value: "registry_record",
+    label: { en: "Registry record", pt: "Ficha cadastral" }
+  },
+  { value: "photo", label: { en: "Photo", pt: "Fotografia" } },
+  {
+    value: "permit_document",
+    label: { en: "Permit document", pt: "Portaria / outorga" }
+  },
+  {
+    value: "condition_evidence",
+    label: { en: "Condition evidence", pt: "Comprovante de condicionante" }
+  },
+  { value: "pump_curve", label: { en: "Pump curve", pt: "Curva da bomba" } },
+  {
+    value: "field_sheet",
+    label: { en: "Field sheet", pt: "Planilha de campo" }
+  },
+  {
+    value: "test_report",
+    label: {
+      en: "Pumping test report",
+      pt: "Relat\xF3rio de teste de bombeamento"
+    }
+  },
+  {
+    value: "lab_report",
+    label: { en: "Lab report", pt: "Laudo laboratorial" }
+  },
+  { value: "invoice", label: { en: "Invoice", pt: "Nota fiscal" } }
+];
+var DOCUMENT_TYPE_SUGGESTIONS = {
+  root: ["drilling_report", "as_built_drawing", "registry_record", "photo"],
+  pump: ["pump_curve", "invoice", "photo"],
+  meter: ["photo", "invoice", "condition_evidence"],
+  permit: ["permit_document", "photo"],
+  condition: ["condition_evidence", "photo"],
+  permit_history: ["permit_document", "invoice", "photo"],
+  event: ["field_sheet", "photo"],
+  history: ["condition_evidence", "photo", "invoice"],
+  sample: ["lab_report", "field_sheet", "photo", "condition_evidence"]
+};
+
+// src/vocab/construction.vocab.ts
+var DRILLING_METHODS = [
+  { value: "rotary", label: { en: "Rotary", pt: "Rotativo" } },
+  { value: "percussion", label: { en: "Percussion", pt: "Percuss\xE3o" } },
+  { value: "cable_tool", label: { en: "Cable tool", pt: "Percuss\xE3o a cabo" } },
+  { value: "auger", label: { en: "Auger", pt: "Trado" } },
+  {
+    value: "air_hammer",
+    label: { en: "Air hammer", pt: "Martelo pneum\xE1tico" }
+  }
+];
+var CONSTRUCTION_MATERIALS = [
+  { value: "pvc", label: { en: "PVC", pt: "PVC" } },
+  {
+    value: "geomechanical_pvc",
+    label: { en: "Geomechanical PVC", pt: "PVC geomec\xE2nico" }
+  },
+  { value: "carbon_steel", label: { en: "Carbon steel", pt: "A\xE7o carbono" } },
+  {
+    value: "galvanized_steel",
+    label: { en: "Galvanized steel", pt: "A\xE7o galvanizado" }
+  },
+  {
+    value: "stainless_steel",
+    label: { en: "Stainless steel", pt: "A\xE7o inox" }
+  },
+  { value: "fiberglass", label: { en: "Fiberglass", pt: "Fibra de vidro" } }
+];
+var SCREEN_SLOT_TYPES = [
+  {
+    value: "continuous_slot",
+    label: { en: "Continuous slot", pt: "Espiralado (tipo Johnson)" }
+  },
+  { value: "slotted", label: { en: "Slotted", pt: "Ranhurado" } },
+  { value: "bridge_slot", label: { en: "Bridge slot", pt: "Tipo ponte" } },
+  { value: "louver", label: { en: "Louver", pt: "Veneziana" } },
+  { value: "perforated", label: { en: "Perforated", pt: "Perfurado" } },
+  { value: "nold", label: { en: "Nold type", pt: "Tipo Nold" } }
+];
+var CENTRALIZER_TYPES = [
+  { value: "spring_bow", label: { en: "Spring bow", pt: "Mola (spring bow)" } },
+  { value: "rigid", label: { en: "Rigid", pt: "R\xEDgido" } },
+  { value: "semi_rigid", label: { en: "Semi-rigid", pt: "Semirr\xEDgido" } },
+  { value: "polymer", label: { en: "Polymer", pt: "Polim\xE9rico" } },
+  { value: "carbon_steel", label: { en: "Carbon steel", pt: "A\xE7o carbono" } },
+  {
+    value: "galvanized_steel",
+    label: { en: "Galvanized steel", pt: "A\xE7o galvanizado" }
+  },
+  {
+    value: "stainless_steel",
+    label: { en: "Stainless steel", pt: "A\xE7o inox" }
+  }
+];
+var CEMENT_PAD_TYPES = [
+  { value: "concrete", label: { en: "Concrete", pt: "Concreto" } },
+  {
+    value: "reinforced_concrete",
+    label: { en: "Reinforced concrete", pt: "Concreto armado" }
+  },
+  { value: "cement", label: { en: "Cement", pt: "Cimento" } },
+  { value: "mortar", label: { en: "Mortar", pt: "Argamassa" } }
+];
+
+// src/vocab/general.vocab.ts
+var WELL_TYPES = [
+  { value: "tubular", label: { en: "Tubular", pt: "Tubular" } },
+  {
+    value: "hand_dug",
+    label: { en: "Hand dug", pt: "Cacimba / po\xE7o escavado" }
+  },
+  { value: "horizontal", label: { en: "Horizontal", pt: "Horizontal" } },
+  {
+    value: "infiltration_gallery",
+    label: { en: "Infiltration gallery", pt: "Galeria de infiltra\xE7\xE3o" }
+  },
+  {
+    value: "artesian",
+    label: { en: "Artesian (deprecated)", pt: "Artesiano (obsoleto)" },
+    deprecated: true
+  }
+];
+var WELL_PURPOSES = [
+  {
+    value: "production",
+    label: { en: "Production", pt: "Produ\xE7\xE3o / capta\xE7\xE3o" }
+  },
+  {
+    value: "monitoring",
+    label: { en: "Monitoring well", pt: "Po\xE7o de monitoramento" }
+  },
+  { value: "piezometer", label: { en: "Piezometer", pt: "Piez\xF4metro" } },
+  {
+    value: "water_level_indicator",
+    label: {
+      en: "Water level indicator",
+      pt: "INA \u2014 indicador de n\xEDvel d'\xE1gua"
+    }
+  },
+  {
+    value: "observation",
+    label: { en: "Observation well", pt: "Po\xE7o de observa\xE7\xE3o" }
+  },
+  {
+    value: "exploration",
+    label: { en: "Exploration", pt: "Pesquisa / explorat\xF3rio" }
+  },
+  {
+    value: "injection",
+    label: { en: "Injection / recharge", pt: "Inje\xE7\xE3o / recarga" }
+  },
+  { value: "dewatering", label: { en: "Dewatering", pt: "Rebaixamento" } }
+];
+
+// src/vocab/history.vocab.ts
+var HISTORY_LOG_CATEGORIES = [
+  { value: "maintenance", label: { en: "Maintenance", pt: "Manuten\xE7\xE3o" } },
+  { value: "inspection", label: { en: "Inspection", pt: "Inspe\xE7\xE3o" } },
+  { value: "incident", label: { en: "Incident", pt: "Incidente" } },
+  { value: "event", label: { en: "Event", pt: "Evento" } },
+  {
+    value: "status_change",
+    label: { en: "Status change", pt: "Mudan\xE7a de situa\xE7\xE3o" }
+  }
+];
+var HISTORY_LOG_SEVERITIES = [
+  { value: "low", label: { en: "Low", pt: "Baixa" } },
+  { value: "medium", label: { en: "Medium", pt: "M\xE9dia" } },
+  { value: "high", label: { en: "High", pt: "Alta" } },
+  { value: "critical", label: { en: "Critical", pt: "Cr\xEDtica" } }
+];
+
+// src/vocab/hydrodynamic.vocab.ts
+var HYDRODYNAMIC_EVENT_TYPES = [
+  {
+    value: "spot_measurement",
+    label: { en: "Spot measurement", pt: "Medi\xE7\xE3o pontual" }
+  },
+  {
+    value: "constant_rate",
+    label: { en: "Constant rate", pt: "Vaz\xE3o constante" }
+  },
+  { value: "step_drawdown", label: { en: "Step drawdown", pt: "Escalonada" } },
+  { value: "airlift", label: { en: "Air-lift", pt: "Air-lift" } },
+  {
+    value: "recovery_only",
+    label: { en: "Recovery only", pt: "Recupera\xE7\xE3o" }
+  }
+];
+var MEASUREMENT_METHODS = [
+  {
+    value: "electric_probe",
+    label: { en: "Electric probe", pt: "Sonda el\xE9trica" }
+  },
+  {
+    value: "pressure_transducer",
+    label: { en: "Pressure transducer", pt: "Transdutor de press\xE3o" }
+  },
+  { value: "air_line", label: { en: "Air line", pt: "Linha de ar" } },
+  { value: "tape", label: { en: "Tape", pt: "Trena" } }
+];
+var AQUIFER_ANALYSIS_METHODS = [
+  { value: "cooper_jacob", label: { en: "Cooper-Jacob", pt: "Cooper-Jacob" } },
+  { value: "theis", label: { en: "Theis", pt: "Theis" } },
+  { value: "neuman", label: { en: "Neuman", pt: "Neuman" } },
+  { value: "hantush", label: { en: "Hantush", pt: "Hantush" } },
+  {
+    value: "birsoy_summers",
+    label: { en: "Birsoy-Summers", pt: "Birsoy-Summers" }
+  },
+  { value: "eden_hazel", label: { en: "Eden-Hazel", pt: "Eden-Hazel" } },
+  {
+    value: "visual_inspection",
+    label: { en: "Visual inspection", pt: "Inspe\xE7\xE3o visual" }
+  }
+];
+
+// src/vocab/operation.vocab.ts
+var PUMP_TYPES = [
+  {
+    value: "submersible",
+    label: { en: "Submersible pump", pt: "Bomba submersa" }
+  },
+  {
+    value: "vertical_turbine",
+    label: { en: "Vertical turbine pump", pt: "Bomba de eixo vertical" }
+  },
+  { value: "jet", label: { en: "Jet pump", pt: "Bomba injetora" } },
+  {
+    value: "progressive_cavity",
+    label: { en: "Progressive cavity pump", pt: "Bomba helicoidal" }
+  },
+  { value: "hand_pump", label: { en: "Hand pump", pt: "Bomba manual" } },
+  {
+    value: "compressor_airlift",
+    label: { en: "Compressor (air-lift)", pt: "Compressor (air-lift)" }
+  }
+];
+var POWER_SOURCES = [
+  { value: "grid", label: { en: "Grid", pt: "Rede el\xE9trica" } },
+  { value: "solar", label: { en: "Solar", pt: "Solar" } },
+  { value: "diesel", label: { en: "Diesel", pt: "Diesel" } },
+  { value: "hybrid", label: { en: "Hybrid", pt: "H\xEDbrido" } }
+];
+var METER_TYPES = [
+  { value: "mechanical", label: { en: "Mechanical", pt: "Mec\xE2nico" } },
+  {
+    value: "electromagnetic",
+    label: { en: "Electromagnetic", pt: "Eletromagn\xE9tico" }
+  },
+  { value: "ultrasonic", label: { en: "Ultrasonic", pt: "Ultrass\xF4nico" } }
+];
+var READING_SOURCES = [
+  { value: "manual", label: { en: "Manual", pt: "Manual" } },
+  { value: "telemetry", label: { en: "Telemetry", pt: "Telemetria" } }
+];
+var ESTIMATION_METHODS = [
+  {
+    value: "flow_time",
+    label: { en: "Flow \xD7 operating time", pt: "Vaz\xE3o \xD7 tempo de opera\xE7\xE3o" }
+  },
+  {
+    value: "energy",
+    label: { en: "Energy consumption", pt: "Consumo de energia" }
+  },
+  {
+    value: "user_statement",
+    label: { en: "User statement", pt: "Informado pelo usu\xE1rio" }
+  }
+];
+var MAINTENANCE_TYPES = [
+  { value: "inspection", label: { en: "Inspection", pt: "Inspe\xE7\xE3o" } },
+  { value: "cleaning", label: { en: "Cleaning", pt: "Limpeza" } },
+  {
+    value: "redevelopment",
+    label: { en: "Redevelopment", pt: "Redesenvolvimento" }
+  },
+  { value: "disinfection", label: { en: "Disinfection", pt: "Desinfec\xE7\xE3o" } },
+  {
+    value: "pump_service",
+    label: { en: "Pump service", pt: "Manuten\xE7\xE3o da bomba" }
+  },
+  {
+    value: "meter_calibration",
+    label: { en: "Meter calibration", pt: "Aferi\xE7\xE3o do hidr\xF4metro" }
+  },
+  {
+    value: "video_inspection",
+    label: {
+      en: "Video inspection / optical logging",
+      pt: "Filmagem / perfilagem \xF3tica"
+    }
+  },
+  {
+    value: "level_measurement",
+    label: { en: "Level measurement", pt: "Medi\xE7\xE3o de n\xEDvel" }
+  },
+  {
+    value: "pump_test",
+    label: { en: "Pumping test", pt: "Teste de bombeamento" }
+  },
+  {
+    value: "water_sampling",
+    label: { en: "Water sampling", pt: "Coleta de \xE1gua" }
+  }
+];
+
+// src/vocab/permit.vocab.ts
+var PERMIT_TYPES = [
+  {
+    value: "abstraction_permit",
+    label: { en: "Abstraction permit", pt: "Outorga de direito de uso" }
+  },
+  {
+    value: "preliminary_permit",
+    label: { en: "Preliminary permit", pt: "Outorga pr\xE9via" }
+  },
+  {
+    value: "exemption",
+    label: { en: "Exemption", pt: "Dispensa / uso insignificante" }
+  },
+  { value: "registration", label: { en: "Registration", pt: "Cadastro" } },
+  {
+    value: "dewatering_permit",
+    label: { en: "Dewatering permit", pt: "Outorga para rebaixamento" }
+  },
+  {
+    value: "drilling_permit",
+    label: { en: "Drilling permit", pt: "Autoriza\xE7\xE3o de perfura\xE7\xE3o" }
+  }
+];
+var WATER_USES = [
+  {
+    value: "human_supply",
+    label: { en: "Human supply", pt: "Abastecimento humano" }
+  },
+  { value: "industrial", label: { en: "Industrial", pt: "Industrial" } },
+  { value: "mining", label: { en: "Mining", pt: "Minera\xE7\xE3o" } },
+  { value: "irrigation", label: { en: "Irrigation", pt: "Irriga\xE7\xE3o" } },
+  {
+    value: "livestock",
+    label: { en: "Livestock", pt: "Dessedenta\xE7\xE3o animal" }
+  },
+  {
+    value: "commercial",
+    label: { en: "Commercial", pt: "Comercial / servi\xE7os" }
+  }
+];
+var CONDITION_CATEGORIES = [
+  {
+    value: "monitoring",
+    label: { en: "Monitoring", pt: "Monitoramento" },
+    description: {
+      en: "Water level, flow, abstracted volume and water quality monitoring/sampling",
+      pt: "Monitoramento/amostragem de n\xEDvel, vaz\xE3o, volume captado e qualidade da \xE1gua"
+    }
+  },
+  {
+    value: "reporting",
+    label: { en: "Reporting", pt: "Relat\xF3rios e declara\xE7\xF5es" },
+    description: {
+      en: "Periodic reports and volume/flow declarations submitted to the authority",
+      pt: "Relat\xF3rios peri\xF3dicos e declara\xE7\xF5es de volume/vaz\xE3o entregues ao \xF3rg\xE3o"
+    }
+  },
+  {
+    value: "equipment_installation",
+    label: { en: "Equipment installation", pt: "Instala\xE7\xE3o de equipamentos" },
+    description: {
+      en: "Meters (hidr\xF4metro), level gauges, sampling taps, telemetry",
+      pt: "Hidr\xF4metro, medidor de n\xEDvel, torneira de amostragem, telemetria"
+    }
+  },
+  {
+    value: "well_protection",
+    label: { en: "Well protection", pt: "Prote\xE7\xE3o do po\xE7o" },
+    description: {
+      en: "Sanitary slab, seal, protection perimeter, wellhead closure",
+      pt: "Laje de prote\xE7\xE3o, selo sanit\xE1rio, per\xEDmetro de prote\xE7\xE3o, tampa do po\xE7o"
+    }
+  },
+  {
+    value: "environmental",
+    label: { en: "Environmental", pt: "Ambiental" },
+    description: {
+      en: "Environmental measures, compensation, licensing of the activity",
+      pt: "Medidas ambientais, compensa\xE7\xE3o, licenciamento da atividade"
+    }
+  },
+  {
+    value: "legal",
+    label: { en: "Legal / administrative", pt: "Legal / administrativo" },
+    description: {
+      en: "Renewal request, fees, registrations, document submissions",
+      pt: "Pedido de renova\xE7\xE3o, taxas, cadastros, entrega de documentos"
+    }
+  }
+];
+var PERMIT_HISTORY_TYPES = [
+  { value: "filing", label: { en: "Filing", pt: "Protocolo" } },
+  { value: "process", label: { en: "Process", pt: "Andamento" } },
+  { value: "notification", label: { en: "Notification", pt: "Notifica\xE7\xE3o" } },
+  { value: "fee", label: { en: "Fee", pt: "Taxa" } },
+  { value: "inspection", label: { en: "Inspection", pt: "Vistoria" } },
+  { value: "decision", label: { en: "Decision", pt: "Decis\xE3o" } },
+  { value: "renewal", label: { en: "Renewal", pt: "Renova\xE7\xE3o" } }
+];
+
+// src/vocab/vocab.ts
+function getVocabEntry(vocab, value) {
+  if (value === void 0) return void 0;
+  return vocab.find((entry) => entry.value === value);
+}
+function isVocabValue(vocab, value) {
+  return getVocabEntry(vocab, value) !== void 0;
+}
+function getVocabLabel(vocab, value, locale) {
+  const entry = getVocabEntry(vocab, value);
+  return entry ? resolveLanguageText(entry.label, locale) : value;
+}
+function formatVocabList(vocab, values, locale) {
+  return (values ?? []).map((v) => getVocabLabel(vocab, v, locale)).join(", ");
+}
+function vocabValues(vocab, { includeDeprecated = false } = {}) {
+  return vocab.filter((entry) => includeDeprecated || !entry.deprecated).map((entry) => entry.value);
+}
+
+// src/vocab/closed.vocab.ts
+function closedVocab() {
+  return (entries) => entries;
+}
+var valuesOf = (vocab) => vocab.map((entry) => entry.value);
+var WELL_STATUSES = closedVocab()([
+  { value: "active", label: { en: "Active", pt: "Ativo" } },
+  {
+    value: "maintenance",
+    label: { en: "Under maintenance", pt: "Em manuten\xE7\xE3o" }
+  },
+  { value: "inactive", label: { en: "Inactive", pt: "Paralisado" } },
+  {
+    value: "decommissioned",
+    label: { en: "Decommissioned", pt: "Desativado" }
+  },
+  { value: "abandoned", label: { en: "Abandoned", pt: "Abandonado" } }
+]);
+var PERMIT_ADMINISTRATIVE_STATUSES = closedVocab()([
+  { value: "requested", label: { en: "Requested", pt: "Requerida" } },
+  { value: "granted", label: { en: "Granted", pt: "Concedida" } },
+  { value: "suspended", label: { en: "Suspended", pt: "Suspensa" } },
+  { value: "revoked", label: { en: "Revoked", pt: "Revogada" } },
+  { value: "denied", label: { en: "Denied", pt: "Indeferida" } },
+  { value: "withdrawn", label: { en: "Withdrawn", pt: "Cancelada" } }
+]);
+var VOLUME_LIMIT_PERIODS = closedVocab()([
+  { value: "daily", label: { en: "Daily", pt: "Di\xE1rio" } },
+  { value: "monthly", label: { en: "Monthly", pt: "Mensal" } },
+  { value: "annual", label: { en: "Annual", pt: "Anual" } }
+]);
+var PRODUCTION_ENTRY_TYPES = closedVocab()([
+  {
+    value: "meter_reading",
+    label: { en: "Meter reading", pt: "Leitura de hidr\xF4metro" }
+  },
+  {
+    value: "estimated_volume",
+    label: { en: "Estimated volume", pt: "Volume estimado" }
+  }
+]);
+var RESULT_QUALIFIERS = closedVocab()([
+  { value: "<", label: { en: "< less than", pt: "< menor que" } },
+  { value: ">", label: { en: "> greater than", pt: "> maior que" } },
+  { value: "not_detected", label: { en: "Not detected", pt: "N\xE3o detectado" } },
+  { value: "estimated", label: { en: "Estimated", pt: "Estimado" } }
+]);
+var RESULT_FRACTIONS = closedVocab()([
+  { value: "total", label: { en: "Total", pt: "Total" } },
+  { value: "dissolved", label: { en: "Dissolved", pt: "Dissolvida" } },
+  { value: "suspended", label: { en: "Suspended", pt: "Suspensa" } }
+]);
+var MEASUREMENT_LOCATIONS = closedVocab()([
+  { value: "field", label: { en: "Field", pt: "Campo" } },
+  { value: "lab", label: { en: "Lab", pt: "Laborat\xF3rio" } }
+]);
+var VALIDATION_STATUSES = closedVocab()([
+  { value: "unvalidated", label: { en: "Unvalidated", pt: "N\xE3o validado" } },
+  { value: "validated", label: { en: "Validated", pt: "Validado" } },
+  { value: "qualified", label: { en: "Qualified", pt: "Qualificado" } },
+  { value: "rejected", label: { en: "Rejected", pt: "Rejeitado" } }
+]);
+var PARAMETER_GROUPS = closedVocab()([
+  {
+    value: "physical",
+    label: { en: "Physical / field", pt: "F\xEDsico / campo" }
+  },
+  { value: "aggregate", label: { en: "Aggregate", pt: "Agregados" } },
+  { value: "major_ion", label: { en: "Major ions", pt: "\xCDons maiores" } },
+  { value: "nutrient", label: { en: "Nutrients", pt: "Nutrientes" } },
+  { value: "organic", label: { en: "Organic", pt: "Org\xE2nicos" } },
+  { value: "disinfection", label: { en: "Disinfection", pt: "Desinfec\xE7\xE3o" } },
+  {
+    value: "mining_redox",
+    label: { en: "Mining and redox", pt: "Minera\xE7\xE3o e redox" }
+  },
+  { value: "metal", label: { en: "Metals / trace", pt: "Metais / tra\xE7o" } },
+  { value: "microbiology", label: { en: "Microbiology", pt: "Microbiologia" } },
+  {
+    value: "radioactivity",
+    label: { en: "Radioactivity", pt: "Radioatividade" }
+  }
+]);
+var WELL_STATUS_VALUES = valuesOf(WELL_STATUSES);
+var PERMIT_ADMINISTRATIVE_STATUS_VALUES = valuesOf(
+  PERMIT_ADMINISTRATIVE_STATUSES
+);
+var QUALIFIER_VALUES = valuesOf(RESULT_QUALIFIERS);
+var FRACTION_VALUES = valuesOf(RESULT_FRACTIONS);
+var MEASURED_IN_VALUES = valuesOf(MEASUREMENT_LOCATIONS);
+var FILTRATION_LOCATION_VALUES = valuesOf(MEASUREMENT_LOCATIONS);
+var VALIDATION_STATUS_VALUES = valuesOf(VALIDATION_STATUSES);
+var PARAMETER_GROUP_VALUES = valuesOf(PARAMETER_GROUPS);
+var NUMERIC_QUALIFIERS = [
+  "<",
+  ">",
+  "estimated"
+];
+var PARENT_SAMPLE_TYPES = [
+  "field_duplicate",
+  "split_sample"
+];
+var BLANK_SAMPLE_TYPES = [
+  "field_blank",
+  "trip_blank",
+  "equipment_blank"
+];
+
+// src/vocab/waterSample.vocab.ts
+var SAMPLE_TYPES = [
+  { value: "routine", label: { en: "Routine", pt: "Rotina" } },
+  {
+    value: "field_duplicate",
+    label: { en: "Field duplicate", pt: "Duplicata de campo" }
+  },
+  {
+    value: "split_sample",
+    label: { en: "Split sample", pt: "Amostra dividida (split)" }
+  },
+  { value: "field_blank", label: { en: "Field blank", pt: "Branco de campo" } },
+  {
+    value: "trip_blank",
+    label: { en: "Trip blank", pt: "Branco de transporte" }
+  },
+  {
+    value: "equipment_blank",
+    label: { en: "Equipment blank", pt: "Branco de equipamento" }
+  }
+];
+var SAMPLING_METHODS = [
+  {
+    value: "low_flow",
+    label: { en: "Low flow", pt: "Purga de baixa vaz\xE3o (micropurga)" }
+  },
+  {
+    value: "volumetric_purge",
+    label: { en: "Volumetric purge", pt: "Purga de volume determinado" }
+  },
+  { value: "no_purge", label: { en: "No purge", pt: "Amostragem sem purga" } },
+  {
+    value: "pump_discharge",
+    label: { en: "Pump discharge", pt: "Bomba de produ\xE7\xE3o em opera\xE7\xE3o" }
+  }
+];
+var SAMPLING_POINT_TYPES = [
+  {
+    value: "pump_discharge",
+    label: { en: "Pump discharge", pt: "Sa\xEDda da bomba de produ\xE7\xE3o" }
+  },
+  {
+    value: "wellhead_tap",
+    label: { en: "Wellhead tap", pt: "Torneira do cavalete" }
+  },
+  { value: "in_well", label: { en: "In well", pt: "Dentro do po\xE7o" } }
+];
+var SAMPLING_DEVICES = [
+  {
+    value: "bailer",
+    label: { en: "Bailer", pt: "Bailer (amostrador de reten\xE7\xE3o)" }
+  },
+  {
+    value: "discrete_depth_sampler",
+    label: {
+      en: "Discrete depth sampler",
+      pt: "Amostrador pontual de profundidade"
+    }
+  },
+  {
+    value: "passive_diffusion_bag",
+    label: { en: "Passive diffusion bag", pt: "Bolsa de difus\xE3o passiva" }
+  },
+  {
+    value: "grab_sleeve",
+    label: {
+      en: "Grab sleeve (HydraSleeve)",
+      pt: "Amostrador passivo tipo luva (HydraSleeve)"
+    }
+  },
+  {
+    value: "low_flow_pump",
+    label: { en: "Low-flow pump", pt: "Bomba de baixa vaz\xE3o" }
+  },
+  {
+    value: "packer_pump",
+    label: { en: "Packer pump", pt: "Bomba com obturador (packer)" }
+  }
+];
+
 // src/utils/units.ts
 var FEET_PER_METER = 3.280839895;
 var METERS_PER_FOOT = 0.3048;
@@ -1060,6 +3128,11 @@ var M3H_TO_USGPM = 4.402867361;
 var M2S_TO_M2D = 86400;
 var PSI_PER_KPA = 0.145037738;
 var SLOT_MM = 0.0254;
+var KW_PER_CV = 0.73549875;
+var KW_PER_HP = 0.745699872;
+var LITERS_PER_M3 = 1e3;
+var FT3_PER_M3 = 35.314666721;
+var USGAL_PER_M3 = 264.172052358;
 function metersToFeet(m) {
   return m * FEET_PER_METER;
 }
@@ -1084,6 +3157,68 @@ function cubicMeterPerHourToUsGallonsPerMinute(q) {
 function usGallonsPerMinuteToCubicMeterPerHour(q) {
   return q / M3H_TO_USGPM;
 }
+function litersToCubicMeters(l) {
+  return l / LITERS_PER_M3;
+}
+function cubicMetersToLiters(m3) {
+  return m3 * LITERS_PER_M3;
+}
+function cubicMetersToCubicFeet(m3) {
+  return m3 * FT3_PER_M3;
+}
+function cubicFeetToCubicMeters(ft3) {
+  return ft3 / FT3_PER_M3;
+}
+function cubicMetersToUsGallons(m3) {
+  return m3 * USGAL_PER_M3;
+}
+function usGallonsToCubicMeters(gal) {
+  return gal / USGAL_PER_M3;
+}
+function cvToKilowatts(cv) {
+  return cv * KW_PER_CV;
+}
+function kilowattsToCv(kw) {
+  return kw / KW_PER_CV;
+}
+function hpToKilowatts(hp) {
+  return hp * KW_PER_HP;
+}
+function kilowattsToHp(kw) {
+  return kw / KW_PER_HP;
+}
+function flowFromCanonical(m3h, unit) {
+  if (unit === "L/s") return cubicMeterPerHourToLitersPerSecond(m3h);
+  if (unit === "gpm") return cubicMeterPerHourToUsGallonsPerMinute(m3h);
+  return m3h;
+}
+function flowToCanonical(value, unit) {
+  if (unit === "L/s") return litersPerSecondToCubicMeterPerHour(value);
+  if (unit === "gpm") return usGallonsPerMinuteToCubicMeterPerHour(value);
+  return value;
+}
+function powerFromCanonical(kw, unit) {
+  if (unit === "cv") return kilowattsToCv(kw);
+  if (unit === "hp") return kilowattsToHp(kw);
+  return kw;
+}
+function powerToCanonical(value, unit) {
+  if (unit === "cv") return cvToKilowatts(value);
+  if (unit === "hp") return hpToKilowatts(value);
+  return value;
+}
+function volumeFromCanonical(m3, unit) {
+  if (unit === "L") return cubicMetersToLiters(m3);
+  if (unit === "ft3") return cubicMetersToCubicFeet(m3);
+  if (unit === "gal") return cubicMetersToUsGallons(m3);
+  return m3;
+}
+function volumeToCanonical(value, unit) {
+  if (unit === "L") return litersToCubicMeters(value);
+  if (unit === "ft3") return cubicFeetToCubicMeters(value);
+  if (unit === "gal") return usGallonsToCubicMeters(value);
+  return value;
+}
 function squareMeterPerSecondToSquareMeterPerDay(t) {
   return t * M2S_TO_M2D;
 }
@@ -1121,64 +3256,227 @@ function minutesToHours(min) {
 function hoursToMinutes(h) {
   return h * 60;
 }
+var MG_L_PER_UNIT = {
+  "g/L": 1e3,
+  "mg/L": 1,
+  "ug/L": 1e-3,
+  "ng/L": 1e-6
+};
+function concentrationToCanonical(value, unit) {
+  return value * MG_L_PER_UNIT[unit];
+}
+function concentrationFromCanonical(mgL, unit) {
+  return mgL / MG_L_PER_UNIT[unit];
+}
+function milliSiemensPerMeterToMicroSiemensPerCm(mSm) {
+  return mSm * 10;
+}
+function milliSiemensPerCmToMicroSiemensPerCm(mScm) {
+  return mScm * 1e3;
+}
+function normalizeColorUnit(unit) {
+  const u = unit.trim().toLowerCase().replace(/\s+/g, "");
+  return ["uh", "hazen", "mgpt-co/l", "mgpt/l", "pt-co", "pcu", "tcu"].includes(
+    u
+  ) ? "uH" : void 0;
+}
+function turbidityCodeForUnit(unit) {
+  switch (unit.trim().toUpperCase()) {
+    case "NTU":
+      return "turbidity_ntu";
+    case "FNU":
+      return "turbidity_fnu";
+    case "FAU":
+      return "turbidity_fau";
+    case "FTU":
+    case "UT":
+      return "turbidity";
+    default:
+      return void 0;
+  }
+}
+function expandedToStandardUncertainty(expanded, coverageFactor = 2) {
+  return expanded / coverageFactor;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AQUIFER_ANALYSIS_METHODS,
   AirliftEventSchema,
   AquiferAnalysisSchema,
   AttachmentSchema,
+  BLANK_SAMPLE_TYPES,
+  BR_GM_MS_888_2021,
   BoreHoleSchema,
+  CEMENT_PAD_TYPES,
+  CENTRALIZER_TYPES,
+  CONDITION_CATEGORIES,
+  CONSTRUCTION_MATERIALS,
   CaveSchema,
   CementPadSchema,
   CentralizerSchema,
+  ConditionFulfillmentSchema,
   ConstantRateEventSchema,
+  DOCUMENT_TYPES,
+  DOCUMENT_TYPE_SUGGESTIONS,
+  DRILLING_METHODS,
+  ESTIMATION_METHODS,
+  EU_2020_2184,
+  EstimatedVolumeSchema,
   FGDC_TEXTURES_OPTIONS,
+  FILTRATION_LOCATION_VALUES,
+  FRACTION_VALUES,
+  FiltrationSchema,
   FractureSchema,
+  HISTORY_LOG_CATEGORIES,
+  HISTORY_LOG_SEVERITIES,
+  HYDRODYNAMIC_EVENT_TYPES,
   HistoryLogEntrySchema,
   HoleFillSchema,
   HydrodynamicEventBaseSchema,
   HydrodynamicEventSchema,
+  LaboratorySchema,
   LevelReadingSchema,
   LithologySchema,
   LocationPropertiesSchema,
   LocationSchema,
+  MAINTENANCE_TYPES,
+  MEASURED_IN_VALUES,
+  MEASUREMENT_LOCATIONS,
+  MEASUREMENT_METHODS,
+  METER_TYPES,
+  MeterReadingSchema,
+  MeterSchema,
+  MonthlyGrantSchema,
+  NEPHELOMETRIC_TURBIDITY_CODES,
+  NUMERIC_QUALIFIERS,
+  OperatingRegimeSchema,
+  PARAMETER_GROUPS,
+  PARAMETER_GROUP_VALUES,
+  PARENT_SAMPLE_TYPES,
+  PERMIT_ADMINISTRATIVE_STATUSES,
+  PERMIT_ADMINISTRATIVE_STATUS_VALUES,
+  PERMIT_HISTORY_TYPES,
+  PERMIT_TYPES,
+  POWER_SOURCES,
+  PRODUCTION_ENTRY_TYPES,
+  PUMP_TYPES,
+  ParameterSchema,
+  PermitAdministrativeStatusSchema,
+  PermitConditionSchema,
+  PermitHistoryEntrySchema,
+  PermitSchema,
+  ProductionEntryBaseSchema,
+  ProductionEntrySchema,
+  PumpElectricalSchema,
+  PumpInstallationSchema,
   PumpingStepSchema,
+  PurgeReadingSchema,
+  PurgeSchema,
+  QUALIFIER_VALUES,
+  READING_SOURCES,
+  RESULT_FRACTIONS,
+  RESULT_QUALIFIERS,
   RecoveryOnlyEventSchema,
   RecoveryPhaseSchema,
   ReductionSchema,
+  ResultQualifierSchema,
+  ResultValidationSchema,
+  SAMPLE_TYPES,
+  SAMPLING_DEVICES,
+  SAMPLING_METHODS,
+  SAMPLING_POINT_TYPES,
+  SCREEN_SLOT_TYPES,
   SECTION_KEYS,
+  SamplingPointSchema,
   SpotMeasurementEventSchema,
   StepDrawdownEventSchema,
   SurfaceCaseSchema,
   TextureSchema,
+  TimeResolutionSchema,
+  VALIDATION_STATUSES,
+  VALIDATION_STATUS_VALUES,
+  VISIBILITY_LEAF_KEYS,
+  VISIBILITY_TREE,
+  VOLUME_LIMIT_PERIODS,
+  VolumeLimitSchema,
+  WATER_QUALITY_LIMIT_SETS,
+  WATER_QUALITY_PARAMETERS,
+  WATER_QUALITY_UNITS,
+  WATER_QUALITY_VOCABULARY_VERSION,
+  WATER_USES,
+  WELL_PURPOSES,
+  WELL_STATUSES,
+  WELL_STATUS_VALUES,
+  WELL_TYPES,
+  WHO_GDWQ_2022,
+  WaterQualityResultSchema,
+  WaterSampleSchema,
   WellCaseSchema,
   WellIdSchema,
   WellSchema,
   WellScreenSchema,
+  WellStatusSchema,
+  calculatedWellDepth,
   checkIfProfileIsEmpty,
+  concentrationFromCanonical,
+  concentrationToCanonical,
   convertProfileFromJSON,
+  cubicFeetToCubicMeters,
   cubicMeterPerHourToLitersPerSecond,
   cubicMeterPerHourToUsGallonsPerMinute,
+  cubicMetersToCubicFeet,
+  cubicMetersToLiters,
+  cubicMetersToUsGallons,
+  cvToKilowatts,
   decimalDegreesToDms,
   deserializeWell,
   dmsToDecimalDegrees,
+  expandedToStandardUncertainty,
   feetToMeters,
+  flowFromCanonical,
+  flowToCanonical,
+  formatVocabList,
+  getLimitSet,
+  getParameterDefinition,
+  getParameterLabel,
+  getVocabEntry,
+  getVocabLabel,
+  hasWellData,
   hoursToMinutes,
+  hpToKilowatts,
   inchesToMm,
+  isKnownParameter,
+  isVocabValue,
   isWellEmpty,
   kilopascalToPsi,
+  kilowattsToCv,
+  kilowattsToHp,
   litersPerSecondToCubicMeterPerHour,
+  litersToCubicMeters,
   metersToFeet,
+  milliSiemensPerCmToMicroSiemensPerCm,
+  milliSiemensPerMeterToMicroSiemensPerCm,
   minutesToHours,
   mmToInches,
   mmToSlotNumber,
+  normalizeColorUnit,
+  parameterKey,
   parseWell,
+  powerFromCanonical,
+  powerToCanonical,
   profileToWell,
   psiToKilopascal,
   redactWell,
+  resolveLanguageText,
   serializeWell,
   slotNumberToMm,
   squareMeterPerDayToSquareMeterPerSecond,
   squareMeterPerSecondToSquareMeterPerDay,
-  usGallonsPerMinuteToCubicMeterPerHour
+  turbidityCodeForUnit,
+  usGallonsPerMinuteToCubicMeterPerHour,
+  usGallonsToCubicMeters,
+  vocabValues,
+  volumeFromCanonical,
+  volumeToCanonical
 });
 //# sourceMappingURL=index.cjs.map