@welldot/core 0.1.1 → 0.2.2

package/dist/index.cjs

@@ -20,26 +20,95 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AirliftEventSchema: () => AirliftEventSchema,
+  AquiferAnalysisSchema: () => AquiferAnalysisSchema,
+  AttachmentSchema: () => AttachmentSchema,
   BoreHoleSchema: () => BoreHoleSchema,
   CaveSchema: () => CaveSchema,
   CementPadSchema: () => CementPadSchema,
+  ConstantRateEventSchema: () => ConstantRateEventSchema,
+  FGDC_TEXTURES_OPTIONS: () => FGDC_TEXTURES_OPTIONS,
   FractureSchema: () => FractureSchema,
+  HistoryLogEntrySchema: () => HistoryLogEntrySchema,
   HoleFillSchema: () => HoleFillSchema,
+  HydrodynamicEventBaseSchema: () => HydrodynamicEventBaseSchema,
+  HydrodynamicEventSchema: () => HydrodynamicEventSchema,
+  LevelReadingSchema: () => LevelReadingSchema,
   LithologySchema: () => LithologySchema,
+  LocationPropertiesSchema: () => LocationPropertiesSchema,
+  LocationSchema: () => LocationSchema,
+  PumpingStepSchema: () => PumpingStepSchema,
+  RecoveryOnlyEventSchema: () => RecoveryOnlyEventSchema,
+  RecoveryPhaseSchema: () => RecoveryPhaseSchema,
   ReductionSchema: () => ReductionSchema,
+  SECTION_KEYS: () => SECTION_KEYS,
+  SpotMeasurementEventSchema: () => SpotMeasurementEventSchema,
+  StepDrawdownEventSchema: () => StepDrawdownEventSchema,
   SurfaceCaseSchema: () => SurfaceCaseSchema,
+  TextureSchema: () => TextureSchema,
   WellCaseSchema: () => WellCaseSchema,
+  WellIdSchema: () => WellIdSchema,
   WellSchema: () => WellSchema,
   WellScreenSchema: () => WellScreenSchema,
   checkIfProfileIsEmpty: () => checkIfProfileIsEmpty,
   convertProfileFromJSON: () => convertProfileFromJSON,
+  cubicMeterPerHourToLitersPerSecond: () => cubicMeterPerHourToLitersPerSecond,
+  cubicMeterPerHourToUsGallonsPerMinute: () => cubicMeterPerHourToUsGallonsPerMinute,
+  decimalDegreesToDms: () => decimalDegreesToDms,
+  deserializeWell: () => deserializeWell,
+  dmsToDecimalDegrees: () => dmsToDecimalDegrees,
+  feetToMeters: () => feetToMeters,
+  hoursToMinutes: () => hoursToMinutes,
+  inchesToMm: () => inchesToMm,
+  isWellEmpty: () => isWellEmpty,
+  kilopascalToPsi: () => kilopascalToPsi,
+  litersPerSecondToCubicMeterPerHour: () => litersPerSecondToCubicMeterPerHour,
+  metersToFeet: () => metersToFeet,
+  minutesToHours: () => minutesToHours,
+  mmToInches: () => mmToInches,
+  mmToSlotNumber: () => mmToSlotNumber,
   parseWell: () => parseWell,
-  profileToWell: () => profileToWell
+  profileToWell: () => profileToWell,
+  psiToKilopascal: () => psiToKilopascal,
+  redactWell: () => redactWell,
+  serializeWell: () => serializeWell,
+  slotNumberToMm: () => slotNumberToMm,
+  squareMeterPerDayToSquareMeterPerSecond: () => squareMeterPerDayToSquareMeterPerSecond,
+  squareMeterPerSecondToSquareMeterPerDay: () => squareMeterPerSecondToSquareMeterPerDay,
+  usGallonsPerMinuteToCubicMeterPerHour: () => usGallonsPerMinuteToCubicMeterPerHour
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/validators/well.validators.ts
+var import_defu = require("defu");
 var import_zod = require("zod");
+var mergeWell = (0, import_defu.createDefu)((obj, key, value) => {
+  if (Array.isArray(value)) {
+    obj[key] = 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 WellIdSchema = import_zod.z.object({
+  authority: import_zod.z.string(),
+  id: import_zod.z.string(),
+  primary: import_zod.z.boolean().optional()
+});
+var LocationPropertiesSchema = import_zod.z.object({
+  elevation_datum: import_zod.z.string().optional(),
+  crs: import_zod.z.string().optional(),
+  lat_precision: import_zod.z.number().optional(),
+  lng_precision: import_zod.z.number().optional(),
+  elevation_precision: import_zod.z.number().optional(),
+  original_crs: import_zod.z.string().optional()
+});
+var LocationSchema = import_zod.z.object({
+  lat: import_zod.z.number(),
+  lng: import_zod.z.number(),
+  elevation: import_zod.z.number().optional(),
+  properties: LocationPropertiesSchema.optional()
+});
 var BoreHoleSchema = import_zod.z.object({
   from: import_zod.z.number(),
   to: import_zod.z.number(),
@@ -64,7 +133,7 @@ var WellScreenSchema = import_zod.z.object({
   to: import_zod.z.number(),
   type: import_zod.z.string(),
   diameter: import_zod.z.number(),
-  screen_slot_mm: import_zod.z.number()
+  screen_slot: import_zod.z.number()
 });
 var HoleFillSchema = import_zod.z.object({
   from: import_zod.z.number(),
@@ -84,12 +153,16 @@ var CementPadSchema = import_zod.z.object({
   thickness: import_zod.z.number(),
   length: import_zod.z.number()
 });
+var TextureSchema = import_zod.z.object({
+  code: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+  vocabulary: import_zod.z.string().optional()
+});
 var LithologySchema = import_zod.z.object({
   from: import_zod.z.number(),
   to: import_zod.z.number(),
   description: import_zod.z.string(),
   color: import_zod.z.string(),
-  fgdc_texture: import_zod.z.string(),
+  texture: TextureSchema,
   geologic_unit: import_zod.z.string(),
   aquifer_unit: import_zod.z.string()
 });
@@ -99,7 +172,8 @@ var FractureSchema = import_zod.z.object({
   description: import_zod.z.string(),
   swarm: import_zod.z.boolean(),
   azimuth: import_zod.z.number(),
-  dip: import_zod.z.number()
+  dip: import_zod.z.number(),
+  depth_precision: import_zod.z.number().optional()
 });
 var CaveSchema = import_zod.z.object({
   from: import_zod.z.number(),
@@ -107,35 +181,242 @@ var CaveSchema = import_zod.z.object({
   water_intake: import_zod.z.boolean(),
   description: import_zod.z.string()
 });
+var LevelReadingSchema = import_zod.z.object({
+  elapsed: import_zod.z.number(),
+  depth: import_zod.z.number(),
+  depth_precision: import_zod.z.number().optional(),
+  pressure: import_zod.z.number().optional()
+});
+var RecoveryPhaseSchema = import_zod.z.object({
+  readings: import_zod.z.array(LevelReadingSchema)
+});
+var PumpingStepSchema = import_zod.z.object({
+  rate: import_zod.z.number(),
+  rate_precision: import_zod.z.number().optional(),
+  duration: import_zod.z.number().optional(),
+  readings: import_zod.z.array(LevelReadingSchema).optional()
+});
+var HydrodynamicEventBaseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.string(),
+  datetime: rfc3339(),
+  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()
+});
+var SpotMeasurementEventSchema = HydrodynamicEventBaseSchema.extend({
+  type: import_zod.z.literal("spot_measurement"),
+  static_level: import_zod.z.number(),
+  static_level_precision: import_zod.z.number().optional(),
+  measurement_method: import_zod.z.string().optional(),
+  steps: import_zod.z.array(PumpingStepSchema).max(1).optional(),
+  recovery: RecoveryPhaseSchema.optional()
+});
+var ConstantRateEventSchema = HydrodynamicEventBaseSchema.extend({
+  type: import_zod.z.literal("constant_rate"),
+  static_level: import_zod.z.number().optional(),
+  static_level_precision: import_zod.z.number().optional(),
+  steps: import_zod.z.tuple([PumpingStepSchema]).optional(),
+  recovery: RecoveryPhaseSchema.optional()
+});
+var StepDrawdownEventSchema = HydrodynamicEventBaseSchema.extend({
+  type: import_zod.z.literal("step_drawdown"),
+  static_level: import_zod.z.number().optional(),
+  static_level_precision: import_zod.z.number().optional(),
+  steps: import_zod.z.array(PumpingStepSchema),
+  recovery: RecoveryPhaseSchema.optional()
+});
+var AirliftEventSchema = HydrodynamicEventBaseSchema.extend({
+  type: import_zod.z.literal("airlift"),
+  steps: import_zod.z.array(PumpingStepSchema),
+  recovery: RecoveryPhaseSchema.optional()
+});
+var RecoveryOnlyEventSchema = HydrodynamicEventBaseSchema.extend({
+  type: import_zod.z.literal("recovery_only"),
+  pumping_rate: import_zod.z.number().optional(),
+  pumping_duration: import_zod.z.number().optional(),
+  recovery: RecoveryPhaseSchema
+});
+var HydrodynamicEventSchema = import_zod.z.discriminatedUnion("type", [
+  SpotMeasurementEventSchema,
+  ConstantRateEventSchema,
+  StepDrawdownEventSchema,
+  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 HistoryLogEntrySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  datetime: rfc3339(),
+  updated_at: rfc3339().optional(),
+  category: import_zod.z.string(),
+  description: import_zod.z.string(),
+  author: import_zod.z.string().optional(),
+  severity: import_zod.z.string().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional()
+});
+var AquiferAnalysisSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  datetime: rfc3339(),
+  analyst: import_zod.z.string().optional(),
+  source_event_ids: import_zod.z.array(import_zod.z.string()),
+  method: import_zod.z.string().optional(),
+  static_level: import_zod.z.number().optional(),
+  static_level_precision: import_zod.z.number().optional(),
+  static_level_source_id: import_zod.z.string().optional(),
+  dynamic_level: import_zod.z.number().optional(),
+  dynamic_level_precision: import_zod.z.number().optional(),
+  flow_rate: import_zod.z.number().optional(),
+  flow_rate_precision: import_zod.z.number().optional(),
+  max_flow_rate: import_zod.z.number().optional(),
+  max_flow_rate_precision: import_zod.z.number().optional(),
+  max_flow_rate_basis: import_zod.z.string().optional(),
+  specific_capacity: import_zod.z.number().optional(),
+  transmissivity: import_zod.z.number().optional(),
+  storativity: import_zod.z.number().nullable().optional(),
+  hydraulic_conductivity: import_zod.z.number().optional(),
+  aquifer_thickness: import_zod.z.number().optional(),
+  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()
+});
 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(),
+  well_id: import_zod.z.array(WellIdSchema).optional(),
+  location: LocationSchema.optional(),
+  profiles: import_zod.z.array(
+    import_zod.z.string().url().refine((u) => u.startsWith("https://"), {
+      message: "profiles must be HTTPS URLs"
+    })
+  ).optional(),
   well_type: import_zod.z.string().optional(),
   name: import_zod.z.string().optional(),
   well_driller: import_zod.z.string().optional(),
-  construction_date: 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(),
+  obs: import_zod.z.string().optional(),
   lat: import_zod.z.number().optional(),
   lng: import_zod.z.number().optional(),
   elevation: import_zod.z.number().optional(),
-  obs: import_zod.z.string().optional(),
+  well_depth: import_zod.z.number().optional(),
   bore_hole: import_zod.z.array(BoreHoleSchema),
   well_case: import_zod.z.array(WellCaseSchema),
   reduction: import_zod.z.array(ReductionSchema),
   well_screen: import_zod.z.array(WellScreenSchema),
   surface_case: import_zod.z.array(SurfaceCaseSchema),
   hole_fill: import_zod.z.array(HoleFillSchema),
-  cement_pad: CementPadSchema,
+  cement_pad: CementPadSchema.optional(),
   lithology: import_zod.z.array(LithologySchema),
   fractures: import_zod.z.array(FractureSchema),
-  caves: import_zod.z.array(CaveSchema)
-});
+  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()
+}).passthrough();
+function normalizeV1Fields(raw) {
+  const out = { ...raw };
+  out.version = 2;
+  if ("bole_hole" in out && !("bore_hole" in out)) {
+    out.bore_hole = out.bole_hole;
+    delete out.bole_hole;
+  }
+  if (!("location" in out)) {
+    const lat = out.lat;
+    const lng = out.lng;
+    const elevation = out.elevation;
+    if (lat !== void 0 && lng !== void 0) {
+      out.location = {
+        lat,
+        lng,
+        ...elevation !== void 0 && { elevation }
+      };
+    }
+  }
+  for (const key of [
+    "bore_hole",
+    "well_case",
+    "well_screen",
+    "surface_case",
+    "hole_fill"
+  ]) {
+    const items = out[key];
+    if (Array.isArray(items)) {
+      const hasDiamPol = items.some(
+        (item) => "diam_pol" in item
+      );
+      if (hasDiamPol) {
+        out[key] = items.map((item) => {
+          const { diam_pol, ...rest } = item;
+          return { ...rest, diameter: (diam_pol || 0) * 25.4 };
+        });
+      }
+    }
+  }
+  if (Array.isArray(out.lithology)) {
+    out.lithology = out.lithology.map((item) => {
+      if ("fgdc_texture" in item && !("texture" in item)) {
+        const { fgdc_texture, ...rest } = item;
+        return { ...rest, texture: { code: fgdc_texture, vocabulary: "fgdc" } };
+      }
+      return item;
+    });
+  }
+  if (Array.isArray(out.well_screen)) {
+    out.well_screen = out.well_screen.map(
+      (item) => {
+        if ("screen_slot_mm" in item && !("screen_slot" in item)) {
+          const { screen_slot_mm, ...rest } = item;
+          return { ...rest, screen_slot: screen_slot_mm };
+        }
+        return item;
+      }
+    );
+  }
+  return out;
+}
 function parseWell(json) {
   const raw = JSON.parse(json);
-  return WellSchema.parse(raw);
+  const version = raw.version;
+  if (version !== void 0 && typeof version === "number") {
+    if (version !== 1 && version !== 2) {
+      throw new Error(`Unsupported .well format version: ${version}`);
+    }
+    if (version === 1) {
+      const normalized = normalizeV1Fields(raw);
+      return mergeWell(
+        WellSchema.parse(normalized),
+        normalized
+      );
+    }
+  } else if (version !== void 0) {
+    throw new Error(`Unsupported .well format version: ${String(version)}`);
+  } else {
+    raw.version = 2;
+  }
+  return mergeWell(WellSchema.parse(raw), raw);
 }
 
 // src/utils/well.utils.ts
-var WELL_FORMAT_VERSION = 1;
+var WELL_FORMAT_VERSION = 2;
 var INCHES_TO_MM = 25.4;
+var SECTION_KEYS = [
+  "general",
+  "constructive",
+  "geology",
+  "hydrodynamic",
+  "history"
+];
 var EMPTY_WELL = {
+  version: 2,
   bore_hole: [],
   well_case: [],
   reduction: [],
@@ -150,11 +431,56 @@ var EMPTY_WELL = {
 function createEmptyWell() {
   return JSON.parse(JSON.stringify(EMPTY_WELL));
 }
+function calculatedWellDepth(well) {
+  const lastTo = (items) => items.length ? items[items.length - 1].to : 0;
+  return Math.max(
+    0,
+    lastTo(well.bore_hole),
+    lastTo(well.hole_fill),
+    lastTo(well.reduction),
+    lastTo(well.surface_case),
+    lastTo(well.well_case),
+    lastTo(well.well_screen)
+  );
+}
+function withCalculatedWellDepth(well) {
+  if (well.well_depth != null) return well;
+  const calculated = calculatedWellDepth(well);
+  return calculated > 0 ? { ...well, well_depth: calculated } : well;
+}
 function normalizeLithology(items) {
-  return items.map((item) => ({ aquifer_unit: "", ...item }));
+  return items.map((item) => {
+    const base = { aquifer_unit: "", ...item };
+    if ("fgdc_texture" in base && !("texture" in base)) {
+      const { fgdc_texture, ...rest } = base;
+      return {
+        ...rest,
+        texture: { code: fgdc_texture, vocabulary: "fgdc" }
+      };
+    }
+    return base;
+  });
+}
+function normalizeWellScreens(items) {
+  return items.map((item) => {
+    if ("screen_slot_mm" in item && !("screen_slot" in item)) {
+      const { screen_slot_mm, ...rest } = item;
+      return {
+        ...rest,
+        screen_slot: screen_slot_mm
+      };
+    }
+    return item;
+  });
 }
 function decodeV1Well(raw) {
-  return {
+  const lat = raw.lat;
+  const lng = raw.lng;
+  const elevation = raw.elevation;
+  const hasCoords = lat !== void 0 || lng !== void 0 || elevation !== void 0;
+  const location = hasCoords && lat !== void 0 && lng !== void 0 ? { lat, lng, ...elevation !== void 0 && { elevation } } : void 0;
+  const rawScreens = raw.well_screen ?? [];
+  const decoded = {
     ...createEmptyWell(),
     ...raw.well_type !== void 0 && { well_type: raw.well_type },
     ...raw.name !== void 0 && { name: raw.name },
@@ -164,14 +490,15 @@ function decodeV1Well(raw) {
     ...raw.construction_date !== void 0 && {
       construction_date: raw.construction_date
     },
-    ...raw.lat !== void 0 && { lat: raw.lat },
-    ...raw.lng !== void 0 && { lng: raw.lng },
-    ...raw.elevation !== void 0 && { elevation: raw.elevation },
+    ...lat !== void 0 && { lat },
+    ...lng !== void 0 && { lng },
+    ...elevation !== void 0 && { elevation },
+    ...location !== void 0 && { location },
     ...raw.obs !== void 0 && { obs: raw.obs },
     bore_hole: raw.bore_hole ?? [],
     well_case: raw.well_case ?? [],
     reduction: raw.reduction ?? [],
-    well_screen: raw.well_screen ?? [],
+    well_screen: normalizeWellScreens(rawScreens),
     surface_case: raw.surface_case ?? [],
     hole_fill: raw.hole_fill ?? [],
     ...raw.cement_pad ? { cement_pad: raw.cement_pad } : {},
@@ -179,6 +506,58 @@ function decodeV1Well(raw) {
     fractures: raw.fractures ?? [],
     caves: raw.caves ?? []
   };
+  return mergeWell(decoded, raw);
+}
+function decodeV2Well(raw) {
+  const rawScreens = raw.well_screen ?? [];
+  const decoded = {
+    ...createEmptyWell(),
+    ...raw.version !== void 0 && { version: raw.version },
+    ...raw["@context"] !== void 0 && {
+      "@context": raw["@context"]
+    },
+    ...raw.well_id !== void 0 && {
+      well_id: raw.well_id
+    },
+    ...raw.location !== void 0 && {
+      location: raw.location
+    },
+    ...raw.profiles !== void 0 && {
+      profiles: raw.profiles
+    },
+    ...raw.well_type !== void 0 && { well_type: raw.well_type },
+    ...raw.name !== void 0 && { name: raw.name },
+    ...raw.well_driller !== void 0 && {
+      well_driller: raw.well_driller
+    },
+    ...raw.construction_date !== void 0 && {
+      construction_date: raw.construction_date
+    },
+    ...raw.obs !== void 0 && { obs: raw.obs },
+    ...raw.well_depth !== void 0 && {
+      well_depth: raw.well_depth
+    },
+    bore_hole: raw.bore_hole ?? [],
+    well_case: raw.well_case ?? [],
+    reduction: raw.reduction ?? [],
+    well_screen: normalizeWellScreens(rawScreens),
+    surface_case: raw.surface_case ?? [],
+    hole_fill: raw.hole_fill ?? [],
+    ...raw.cement_pad ? { cement_pad: raw.cement_pad } : {},
+    lithology: normalizeLithology(raw.lithology ?? []),
+    fractures: raw.fractures ?? [],
+    caves: raw.caves ?? [],
+    ...raw.hydrodynamic_events !== void 0 && {
+      hydrodynamic_events: raw.hydrodynamic_events
+    },
+    ...raw.aquifer_analysis !== void 0 && {
+      aquifer_analysis: raw.aquifer_analysis
+    },
+    ...raw.history_logs !== void 0 && {
+      history_logs: raw.history_logs
+    }
+  };
+  return mergeWell(decoded, raw);
 }
 function convertLegacyDiameters(items) {
   if (!items?.length) return items ?? [];
@@ -190,6 +569,9 @@ function convertLegacyDiameters(items) {
 }
 function normalizeConstructive(src) {
   const boreHoleData = src.bole_hole ?? src.bore_hole ?? [];
+  const rawScreens = convertLegacyDiameters(
+    src.well_screen ?? []
+  );
   return {
     bore_hole: convertLegacyDiameters(boreHoleData),
     hole_fill: convertLegacyDiameters(
@@ -201,9 +583,7 @@ function normalizeConstructive(src) {
     well_case: convertLegacyDiameters(
       src.well_case ?? []
     ),
-    well_screen: convertLegacyDiameters(
-      src.well_screen ?? []
-    ),
+    well_screen: normalizeWellScreens(rawScreens),
     reduction: src.reduction ?? [],
     ...src.cement_pad ? { cement_pad: src.cement_pad } : {}
   };
@@ -219,16 +599,18 @@ function normalizeGeologic(raw) {
 function serializeWell(well) {
   const payload = {
     version: WELL_FORMAT_VERSION,
+    ...well["@context"] !== void 0 && { "@context": well["@context"] },
+    ...well.well_id !== void 0 && { well_id: well.well_id },
+    ...well.location !== void 0 && { location: well.location },
+    ...well.profiles !== void 0 && { profiles: well.profiles },
     ...well.well_type !== void 0 && { well_type: well.well_type },
     ...well.name !== void 0 && { name: well.name },
     ...well.well_driller !== void 0 && { well_driller: well.well_driller },
     ...well.construction_date !== void 0 && {
       construction_date: well.construction_date
     },
-    ...well.lat !== void 0 && { lat: well.lat },
-    ...well.lng !== void 0 && { lng: well.lng },
-    ...well.elevation !== void 0 && { elevation: well.elevation },
     ...well.obs !== void 0 && { obs: well.obs },
+    ...well.well_depth !== void 0 && { well_depth: well.well_depth },
     bore_hole: well.bore_hole,
     well_case: well.well_case,
     reduction: well.reduction,
@@ -238,7 +620,14 @@ function serializeWell(well) {
     ...well.cement_pad && { cement_pad: well.cement_pad },
     lithology: well.lithology,
     fractures: well.fractures,
-    caves: well.caves
+    caves: well.caves,
+    ...well.hydrodynamic_events !== void 0 && {
+      hydrodynamic_events: well.hydrodynamic_events
+    },
+    ...well.aquifer_analysis !== void 0 && {
+      aquifer_analysis: well.aquifer_analysis
+    },
+    ...well.history_logs !== void 0 && { history_logs: well.history_logs }
   };
   return JSON.stringify(payload);
 }
@@ -248,6 +637,44 @@ 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 redactWell(well, visibility) {
+  const redacted = { ...well };
+  if (!visibility.general) {
+    delete redacted.well_id;
+    delete redacted.location;
+    delete redacted.well_type;
+    delete redacted.name;
+    delete redacted.well_driller;
+    delete redacted.construction_date;
+    delete redacted.obs;
+    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.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 = [];
+  }
+  return redacted;
+}
 function deserializeWell(jsonString) {
   let raw;
   try {
@@ -259,9 +686,9 @@ function deserializeWell(jsonString) {
     throw new Error("Invalid profile format");
   }
   if (typeof raw.version === "number") {
-    if (raw.version !== 1)
-      throw new Error(`Unsupported .well format version: ${raw.version}`);
-    return decodeV1Well(raw);
+    if (raw.version === 2) return withCalculatedWellDepth(decodeV2Well(raw));
+    if (raw.version === 1) return withCalculatedWellDepth(decodeV1Well(raw));
+    throw new Error(`Unsupported .well format version: ${raw.version}`);
   }
   if (isWellEmpty(raw)) return null;
   const constructiveSource = raw.constructive ?? raw;
@@ -279,32 +706,453 @@ function deserializeWell(jsonString) {
     ...raw.elevation !== void 0 && { elevation: raw.elevation },
     ...raw.obs !== void 0 && { obs: raw.obs }
   };
-  return {
+  return withCalculatedWellDepth({
     ...createEmptyWell(),
     ...metadata,
     ...normalizeConstructive(constructiveSource),
     ...normalizeGeologic(raw)
-  };
+  });
 }
 var profileToWell = serializeWell;
 var checkIfProfileIsEmpty = isWellEmpty;
 var convertProfileFromJSON = deserializeWell;
+
+// src/utils/fgdc.textures.ts
+var FGDC_TEXTURES_OPTIONS = [
+  // --- Surficial Patterns (Series 100) ---
+  { code: 101, label: "Unconsolidated material", pending: true },
+  { code: 102, label: "Alluvium", pending: true },
+  { code: 103, label: "Terrace deposit", pending: true },
+  { code: 104, label: "Floodplain deposit", pending: true },
+  { code: 105, label: "Fan or pediment deposit", pending: true },
+  { code: 106, label: "Eolian sand", pending: true },
+  { code: 107, label: "Silt or loess", pending: true },
+  { code: 108, label: "Clay deposit", pending: true },
+  { code: 109, label: "Colluvium", pending: true },
+  { code: 110, label: "Gravel deposit", pending: true },
+  { code: 111, label: "Residual deposit", pending: true },
+  { code: 112, label: "Playa deposit", pending: true },
+  { code: 113, label: "Lacustrine deposit", pending: true },
+  { code: 114, label: "Marine deposit", pending: true },
+  { code: 115, label: "Beach or bar deposit", pending: true },
+  { code: 116, label: "Organic deposit or peat", pending: true },
+  { code: 117, label: "Swamp or marsh deposit", pending: true },
+  { code: 118, label: "Soil", pending: true },
+  { code: 119, label: "Fill or artificial deposit", pending: true },
+  { code: 120, label: "Surficial pattern 120" },
+  { code: 121, label: "Surficial pattern 121", pending: true },
+  { code: 122, label: "Surficial pattern 122", pending: true },
+  { code: 123, label: "Surficial pattern 123" },
+  { code: 124, label: "Surficial pattern 124", pending: true },
+  { code: 125, label: "Surficial pattern 125", pending: true },
+  { code: 126, label: "Surficial pattern 126", pending: true },
+  { code: 127, label: "Surficial pattern 127", pending: true },
+  { code: 128, label: "Surficial pattern 128", pending: true },
+  { code: 129, label: "Surficial pattern 129", pending: true },
+  { code: 130, label: "Surficial pattern 130", pending: true },
+  { code: 131, label: "Surficial pattern 131", pending: true },
+  { code: 132, label: "Surficial pattern 132" },
+  { code: 133, label: "Surficial pattern 133", pending: true },
+  { code: 134, label: "Surficial pattern 134", pending: true },
+  { code: 135, label: "Surficial pattern 135", pending: true },
+  { code: 136, label: "Surficial pattern 136", pending: true },
+  { code: 137, label: "Surficial pattern 137", pending: true },
+  // --- Sedimentary Patterns (Series 200) ---
+  { code: 201, label: "Sedimentary pattern 201", pending: true },
+  { code: 202, label: "Sedimentary pattern 202", pending: true },
+  { code: 203, label: "Sedimentary pattern 203", pending: true },
+  { code: 204, label: "Sedimentary pattern 204", pending: true },
+  { code: 205, label: "Sedimentary pattern 205", pending: true },
+  { code: 206, label: "Sedimentary pattern 206", pending: true },
+  { code: 207, label: "Sedimentary pattern 207", pending: true },
+  { code: 208, label: "Sedimentary pattern 208", pending: true },
+  { code: 209, label: "Sedimentary pattern 209", pending: true },
+  { code: 210, label: "Sedimentary pattern 210", pending: true },
+  { code: 211, label: "Sedimentary pattern 211", pending: true },
+  { code: 212, label: "Sedimentary pattern 212", pending: true },
+  { code: 213, label: "Sedimentary pattern 213", pending: true },
+  { code: 214, label: "Sedimentary pattern 214", pending: true },
+  { code: 215, label: "Sedimentary pattern 215", pending: true },
+  { code: 216, label: "Sedimentary pattern 216", pending: true },
+  { code: 217, label: "Sedimentary pattern 217", pending: true },
+  { code: 218, label: "Sedimentary pattern 218", pending: true },
+  { code: 219, label: "Sedimentary pattern 219", pending: true },
+  { code: 220, label: "Sedimentary pattern 220", pending: true },
+  { code: 221, label: "Sedimentary pattern 221", pending: true },
+  { code: 222, label: "Sedimentary pattern 222", pending: true },
+  { code: 223, label: "Sedimentary pattern 223", pending: true },
+  { code: 224, label: "Sedimentary pattern 224", pending: true },
+  { code: 225, label: "Sedimentary pattern 225", pending: true },
+  { code: 226, label: "Sedimentary pattern 226", pending: true },
+  { code: 227, label: "Sedimentary pattern 227", pending: true },
+  { code: 228, label: "Sedimentary pattern 228", pending: true },
+  { code: 229, label: "Sedimentary pattern 229", pending: true },
+  { code: 230, label: "Sedimentary pattern 230", pending: true },
+  { code: 231, label: "Sedimentary pattern 231", pending: true },
+  { code: 232, label: "Sedimentary pattern 232", pending: true },
+  { code: 233, label: "Sedimentary pattern 233", pending: true },
+  // --- Igneous Patterns (Series 300) ---
+  { code: 301, label: "Igneous pattern 301", pending: true },
+  { code: 302, label: "Igneous pattern 302", pending: true },
+  { code: 303, label: "Igneous pattern 303", pending: true },
+  { code: 304, label: "Igneous pattern 304", pending: true },
+  { code: 305, label: "Igneous pattern 305", pending: true },
+  { code: 306, label: "Igneous pattern 306", pending: true },
+  { code: 307, label: "Igneous pattern 307", pending: true },
+  { code: 308, label: "Igneous pattern 308", pending: true },
+  { code: 309, label: "Igneous pattern 309", pending: true },
+  { code: 310, label: "Igneous pattern 310", pending: true },
+  { code: 311, label: "Igneous pattern 311", pending: true },
+  { code: 312, label: "Igneous pattern 312", pending: true },
+  { code: 313, label: "Igneous pattern 313", pending: true },
+  { code: 314, label: "Igneous pattern 314", pending: true },
+  { code: 315, label: "Igneous pattern 315", pending: true },
+  { code: 316, label: "Igneous pattern 316", pending: true },
+  { code: 317, label: "Igneous pattern 317", pending: true },
+  { code: 318, label: "Igneous pattern 318", pending: true },
+  { code: 319, label: "Igneous pattern 319", pending: true },
+  { code: 320, label: "Igneous pattern 320", pending: true },
+  { code: 321, label: "Igneous pattern 321", pending: true },
+  { code: 322, label: "Igneous pattern 322", pending: true },
+  { code: 323, label: "Igneous pattern 323", pending: true },
+  { code: 324, label: "Igneous pattern 324", pending: true },
+  { code: 325, label: "Igneous pattern 325", pending: true },
+  { code: 326, label: "Igneous pattern 326", pending: true },
+  { code: 327, label: "Igneous pattern 327", pending: true },
+  { code: 328, label: "Igneous pattern 328", pending: true },
+  { code: 329, label: "Igneous pattern 329", pending: true },
+  { code: 330, label: "Igneous pattern 330", pending: true },
+  { code: 331, label: "Igneous pattern 331", pending: true },
+  // --- Miscellaneous and Metamorphic Patterns (Series 400) ---
+  { code: 401, label: "Miscellaneous pattern 401", pending: true },
+  { code: 402, label: "Miscellaneous pattern 402", pending: true },
+  { code: 403, label: "Miscellaneous pattern 403", pending: true },
+  { code: 404, label: "Miscellaneous pattern 404", pending: true },
+  { code: 405, label: "Miscellaneous pattern 405", pending: true },
+  { code: 406, label: "Miscellaneous pattern 406", pending: true },
+  { code: 407, label: "Miscellaneous pattern 407", pending: true },
+  { code: 408, label: "Miscellaneous pattern 408", pending: true },
+  { code: 409, label: "Miscellaneous pattern 409", pending: true },
+  { code: 410, label: "Miscellaneous pattern 410", pending: true },
+  { code: 411, label: "Miscellaneous pattern 411", pending: true },
+  { code: 412, label: "Miscellaneous pattern 412", pending: true },
+  { code: 413, label: "Miscellaneous pattern 413", pending: true },
+  { code: 414, label: "Miscellaneous pattern 414", pending: true },
+  { code: 415, label: "Miscellaneous pattern 415", pending: true },
+  { code: 416, label: "Miscellaneous pattern 416", pending: true },
+  { code: 417, label: "Miscellaneous pattern 417", pending: true },
+  { code: 418, label: "Miscellaneous pattern 418", pending: true },
+  { code: 419, label: "Miscellaneous pattern 419", pending: true },
+  { code: 420, label: "Miscellaneous pattern 420", pending: true },
+  { code: 421, label: "Miscellaneous pattern 421", pending: true },
+  { code: 422, label: "Miscellaneous pattern 422", pending: true },
+  { code: 423, label: "Miscellaneous pattern 423", pending: true },
+  { code: 424, label: "Miscellaneous pattern 424", pending: true },
+  { code: 425, label: "Miscellaneous pattern 425", pending: true },
+  { code: 426, label: "Miscellaneous pattern 426", pending: true },
+  { code: 427, label: "Miscellaneous pattern 427", pending: true },
+  { code: 428, label: "Miscellaneous pattern 428", pending: true },
+  { code: 429, label: "Miscellaneous pattern 429", pending: true },
+  { code: 430, label: "Miscellaneous pattern 430", pending: true },
+  { code: 431, label: "Miscellaneous pattern 431", pending: true },
+  { code: 432, label: "Miscellaneous pattern 432", pending: true },
+  { code: 433, label: "Miscellaneous pattern 433", pending: true },
+  { code: 434, label: "Miscellaneous pattern 434", pending: true },
+  { code: 435, label: "Miscellaneous pattern 435", pending: true },
+  { code: 436, label: "Miscellaneous pattern 436", pending: true },
+  // --- Glacial Patterns (Series 500) ---
+  { code: 521, label: "Glacial pattern 521", pending: true },
+  { code: 522, label: "Glacial pattern 522", pending: true },
+  { code: 523, label: "Glacial pattern 523", pending: true },
+  { code: 524, label: "Glacial pattern 524", pending: true },
+  { code: 530, label: "Glacial pattern 530", pending: true },
+  { code: 531, label: "Glacial pattern 531", pending: true },
+  { code: 532, label: "Glacial pattern 532", pending: true },
+  { code: 533, label: "Glacial pattern 533", pending: true },
+  { code: 534, label: "Glacial pattern 534", pending: true },
+  { code: 535, label: "Glacial pattern 535", pending: true },
+  { code: 536, label: "Glacial pattern 536", pending: true },
+  { code: 537, label: "Glacial pattern 537", pending: true },
+  { code: 538, label: "Glacial pattern 538", pending: true },
+  { code: 580, label: "Glacial pattern 580", pending: true },
+  { code: 581, label: "Glacial pattern 581", pending: true },
+  { code: 582, label: "Glacial pattern 582", pending: true },
+  { code: 583, label: "Glacial pattern 583", pending: true },
+  { code: 584, label: "Glacial pattern 584", pending: true },
+  { code: 585, label: "Glacial pattern 585", pending: true },
+  { code: 586, label: "Glacial pattern 586", pending: true },
+  { code: 587, label: "Glacial pattern 587", pending: true },
+  { code: 588, label: "Glacial pattern 588", pending: true },
+  { code: 589, label: "Glacial pattern 589", pending: true },
+  { code: 591, label: "Periglacial pattern 591", pending: true },
+  { code: 592, label: "Periglacial pattern 592", pending: true },
+  { code: 593, label: "Periglacial pattern 593", pending: true },
+  { code: 594, label: "Periglacial pattern 594", pending: true },
+  { code: 595, label: "Periglacial pattern 595", pending: true },
+  // --- Sedimentary Lithology Patterns (Series 600) ---
+  { code: 601, label: "Gravel or conglomerate (1st option)" },
+  { code: 602, label: "Gravel or conglomerate (2nd option)" },
+  { code: 603, label: "Crossbedded gravel or conglomerate" },
+  { code: 605, label: "Breccia (1st option)" },
+  { code: 606, label: "Breccia (2nd option)" },
+  { code: 607, label: "Massive sand or sandstone" },
+  { code: 608, label: "Bedded sand or sandstone" },
+  { code: 609, label: "Crossbedded sand or sandstone (1st option)" },
+  { code: 610, label: "Crossbedded sand or sandstone (2nd option)" },
+  { code: 611, label: "Ripple-bedded sand or sandstone" },
+  { code: 612, label: "Argillaceous or shaly sandstone" },
+  { code: 613, label: "Calcareous sandstone" },
+  { code: 614, label: "Dolomitic sandstone" },
+  { code: 616, label: "Silt, siltstone, or shaly silt" },
+  { code: 617, label: "Calcareous siltstone" },
+  { code: 618, label: "Dolomitic siltstone" },
+  { code: 619, label: "Sandy or silty shale" },
+  { code: 620, label: "Clay or clay shale" },
+  { code: 621, label: "Cherty shale" },
+  { code: 622, label: "Dolomitic shale" },
+  { code: 623, label: "Calcareous shale or marl" },
+  { code: 624, label: "Carbonaceous shale" },
+  { code: 625, label: "Oil shale" },
+  { code: 626, label: "Chalk" },
+  { code: 627, label: "Limestone" },
+  { code: 628, label: "Clastic limestone" },
+  { code: 629, label: "Fossiliferous clastic limestone" },
+  { code: 630, label: "Nodular or irregularly bedded limestone" },
+  {
+    code: 631,
+    label: "Limestone, irregular (burrow?) fillings of saccharoidal dolomite"
+  },
+  { code: 632, label: "Crossbedded limestone" },
+  { code: 633, label: "Cherty crossbedded limestone" },
+  { code: 634, label: "Cherty and sandy crossbedded clastic limestone" },
+  { code: 635, label: "Oolitic limestone" },
+  { code: 636, label: "Sandy limestone" },
+  { code: 637, label: "Silty limestone" },
+  { code: 638, label: "Argillaceous or shaly limestone" },
+  { code: 639, label: "Cherty limestone (1st option)" },
+  { code: 640, label: "Cherty limestone (2nd option)" },
+  { code: 641, label: "Dolomitic limestone, limy dolostone, or limy dolomite" },
+  { code: 642, label: "Dolostone or dolomite" },
+  { code: 643, label: "Crossbedded dolostone or dolomite" },
+  { code: 644, label: "Oolitic dolostone or dolomite" },
+  { code: 645, label: "Sandy dolostone or dolomite" },
+  { code: 646, label: "Silty dolostone or dolomite" },
+  { code: 647, label: "Argillaceous or shaly dolostone or dolomite" },
+  { code: 648, label: "Cherty dolostone or dolomite" },
+  { code: 649, label: "Bedded chert (1st option)" },
+  { code: 650, label: "Bedded chert (2nd option)" },
+  { code: 651, label: "Fossiliferous bedded chert" },
+  { code: 652, label: "Fossiliferous rock" },
+  { code: 653, label: "Diatomaceous rock" },
+  { code: 654, label: "Subgraywacke" },
+  { code: 655, label: "Crossbedded subgraywacke" },
+  { code: 656, label: "Ripple-bedded subgraywacke" },
+  { code: 657, label: "Peat" },
+  { code: 658, label: "Coal" },
+  { code: 659, label: "Bony coal or impure coal" },
+  { code: 660, label: "Underclay" },
+  { code: 661, label: "Flint clay" },
+  { code: 662, label: "Bentonite" },
+  { code: 663, label: "Glauconite" },
+  { code: 664, label: "Limonite" },
+  { code: 665, label: "Siderite" },
+  { code: 666, label: "Phosphatic-nodular rock" },
+  { code: 667, label: "Gypsum" },
+  { code: 668, label: "Salt" },
+  { code: 669, label: "Interbedded sandstone and siltstone" },
+  { code: 670, label: "Interbedded sandstone and shale" },
+  { code: 671, label: "Interbedded ripple-bedded sandstone and shale" },
+  {
+    code: 672,
+    label: "Interbedded shale and silty limestone (shale dominant)"
+  },
+  {
+    code: 673,
+    label: "Interbedded shale and limestone, shale dominant (1st option)"
+  },
+  {
+    code: 674,
+    label: "Interbedded shale and limestone, shale dominant (2nd option)"
+  },
+  {
+    code: 675,
+    label: "Interbedded calcareous shale and limestone (shale dominant)"
+  },
+  { code: 676, label: "Interbedded silty limestone and shale" },
+  { code: 677, label: "Interbedded limestone and shale (1st option)" },
+  { code: 678, label: "Interbedded limestone and shale (2nd option)" },
+  { code: 679, label: "Interbedded limestone and shale (limestone dominant)" },
+  { code: 680, label: "Interbedded limestone and calcareous shale" },
+  { code: 681, label: "Till or diamicton (1st option)" },
+  { code: 682, label: "Till or diamicton (2nd option)" },
+  { code: 683, label: "Till or diamicton (3rd option)" },
+  { code: 684, label: "Loess (1st option)" },
+  { code: 685, label: "Loess (2nd option)" },
+  { code: 686, label: "Loess (3rd option)" },
+  // --- Metamorphic Lithology Patterns (Series 700) ---
+  { code: 701, label: "Metamorphism" },
+  { code: 702, label: "Quartzite" },
+  { code: 703, label: "Slate" },
+  { code: 704, label: "Schistose or gneissoid granite" },
+  { code: 705, label: "Schist" },
+  { code: 706, label: "Contorted schist" },
+  { code: 707, label: "Schist and gneiss" },
+  { code: 708, label: "Gneiss" },
+  { code: 709, label: "Contorted gneiss" },
+  { code: 710, label: "Soapstone, talc, or serpentinite" },
+  // --- Igneous and Vein-Matter Lithology Patterns (Series 700 continued) ---
+  { code: 711, label: "Tuffaceous rock" },
+  { code: 712, label: "Crystal tuff" },
+  { code: 713, label: "Devitrified tuff" },
+  { code: 714, label: "Volcanic breccia and tuff" },
+  { code: 715, label: "Volcanic breccia or agglomerate" },
+  { code: 716, label: "Zeolitic rock" },
+  { code: 717, label: "Basaltic flows" },
+  { code: 718, label: "Granite (1st option)" },
+  { code: 719, label: "Granite (2nd option)" },
+  { code: 720, label: "Banded igneous rock" },
+  { code: 721, label: "Igneous rock (1st option)" },
+  { code: 722, label: "Igneous rock (2nd option)" },
+  { code: 723, label: "Igneous rock (3rd option)" },
+  { code: 724, label: "Igneous rock (4th option)" },
+  { code: 725, label: "Igneous rock (5th option)" },
+  { code: 726, label: "Igneous rock (6th option)" },
+  { code: 727, label: "Igneous rock (7th option)" },
+  { code: 728, label: "Igneous rock (8th option)" },
+  { code: 729, label: "Porphyritic rock (1st option)" },
+  { code: 730, label: "Porphyritic rock (2nd option)" },
+  { code: 731, label: "Vitrophyre" },
+  { code: 732, label: "Quartz" },
+  { code: 733, label: "Ore" }
+];
+
+// src/utils/units.ts
+var FEET_PER_METER = 3.280839895;
+var METERS_PER_FOOT = 0.3048;
+var MM_PER_INCH = 25.4;
+var M3H_TO_LS = 1 / 3.6;
+var M3H_TO_USGPM = 4.402867361;
+var M2S_TO_M2D = 86400;
+var PSI_PER_KPA = 0.145037738;
+var SLOT_MM = 0.0254;
+function metersToFeet(m) {
+  return m * FEET_PER_METER;
+}
+function feetToMeters(ft) {
+  return ft * METERS_PER_FOOT;
+}
+function mmToInches(mm) {
+  return mm / MM_PER_INCH;
+}
+function inchesToMm(inches) {
+  return inches * MM_PER_INCH;
+}
+function cubicMeterPerHourToLitersPerSecond(q) {
+  return q * M3H_TO_LS;
+}
+function litersPerSecondToCubicMeterPerHour(q) {
+  return q / M3H_TO_LS;
+}
+function cubicMeterPerHourToUsGallonsPerMinute(q) {
+  return q * M3H_TO_USGPM;
+}
+function usGallonsPerMinuteToCubicMeterPerHour(q) {
+  return q / M3H_TO_USGPM;
+}
+function squareMeterPerSecondToSquareMeterPerDay(t) {
+  return t * M2S_TO_M2D;
+}
+function squareMeterPerDayToSquareMeterPerSecond(t) {
+  return t / M2S_TO_M2D;
+}
+function decimalDegreesToDms(degrees, axis = "lat") {
+  const abs = Math.abs(degrees);
+  const d = Math.floor(abs);
+  const minFloat = (abs - d) * 60;
+  const m = Math.floor(minFloat);
+  const s = (minFloat - m) * 60;
+  const direction = axis === "lat" ? degrees >= 0 ? "N" : "S" : degrees >= 0 ? "E" : "W";
+  return { degrees: d, minutes: m, seconds: s, direction };
+}
+function dmsToDecimalDegrees(dms) {
+  const abs = dms.degrees + dms.minutes / 60 + dms.seconds / 3600;
+  return dms.direction === "S" || dms.direction === "W" ? -abs : abs;
+}
+function slotNumberToMm(slotNumber) {
+  return slotNumber * SLOT_MM;
+}
+function mmToSlotNumber(mm) {
+  return Math.round(mm / SLOT_MM);
+}
+function kilopascalToPsi(kPa) {
+  return kPa * PSI_PER_KPA;
+}
+function psiToKilopascal(psi) {
+  return psi / PSI_PER_KPA;
+}
+function minutesToHours(min) {
+  return min / 60;
+}
+function hoursToMinutes(h) {
+  return h * 60;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AirliftEventSchema,
+  AquiferAnalysisSchema,
+  AttachmentSchema,
   BoreHoleSchema,
   CaveSchema,
   CementPadSchema,
+  ConstantRateEventSchema,
+  FGDC_TEXTURES_OPTIONS,
   FractureSchema,
+  HistoryLogEntrySchema,
   HoleFillSchema,
+  HydrodynamicEventBaseSchema,
+  HydrodynamicEventSchema,
+  LevelReadingSchema,
   LithologySchema,
+  LocationPropertiesSchema,
+  LocationSchema,
+  PumpingStepSchema,
+  RecoveryOnlyEventSchema,
+  RecoveryPhaseSchema,
   ReductionSchema,
+  SECTION_KEYS,
+  SpotMeasurementEventSchema,
+  StepDrawdownEventSchema,
   SurfaceCaseSchema,
+  TextureSchema,
   WellCaseSchema,
+  WellIdSchema,
   WellSchema,
   WellScreenSchema,
   checkIfProfileIsEmpty,
   convertProfileFromJSON,
+  cubicMeterPerHourToLitersPerSecond,
+  cubicMeterPerHourToUsGallonsPerMinute,
+  decimalDegreesToDms,
+  deserializeWell,
+  dmsToDecimalDegrees,
+  feetToMeters,
+  hoursToMinutes,
+  inchesToMm,
+  isWellEmpty,
+  kilopascalToPsi,
+  litersPerSecondToCubicMeterPerHour,
+  metersToFeet,
+  minutesToHours,
+  mmToInches,
+  mmToSlotNumber,
   parseWell,
-  profileToWell
+  profileToWell,
+  psiToKilopascal,
+  redactWell,
+  serializeWell,
+  slotNumberToMm,
+  squareMeterPerDayToSquareMeterPerSecond,
+  squareMeterPerSecondToSquareMeterPerDay,
+  usGallonsPerMinuteToCubicMeterPerHour
 });
 //# sourceMappingURL=index.cjs.map