gtfs 4.11.3 → 4.13.0

package/dist/bin/gtfs-import.js

@@ -0,0 +1,4146 @@
+#!/usr/bin/env node
+
+// src/bin/gtfs-import.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import PrettyError from "pretty-error";
+
+// src/lib/file-utils.ts
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm } from "node:fs/promises";
+import { omit, snakeCase } from "lodash-es";
+import sanitize from "sanitize-filename";
+import untildify from "untildify";
+import StreamZip from "node-stream-zip";
+async function getConfig(argv2) {
+  let config;
+  let data;
+  if (argv2.configPath) {
+    try {
+      data = await readFile(path.resolve(untildify(argv2.configPath)), "utf8");
+    } catch (error) {
+      throw new Error(
+        `Cannot find configuration file at \`${argv2.configPath}\`. Use config-sample.json as a starting point.`
+      );
+    }
+    try {
+      config = Object.assign(JSON.parse(data), argv2);
+    } catch (error) {
+      throw new Error(
+        `Cannot parse configuration file at \`${argv2.configPath}\`. Check to ensure that it is valid JSON.`
+      );
+    }
+  } else if (argv2.gtfsPath || argv2.gtfsUrl || argv2.sqlitePath) {
+    const agencies = [];
+    if (argv2.gtfsPath) {
+      agencies.push({
+        path: argv2.gtfsPath
+      });
+    }
+    if (argv2.gtfsUrl) {
+      agencies.push({
+        url: argv2.gtfsUrl
+      });
+    }
+    config = {
+      agencies,
+      ...omit(argv2, ["path", "url"])
+    };
+  } else if (existsSync(path.resolve("./config.json"))) {
+    try {
+      data = await readFile(path.resolve("./config.json"), "utf8");
+    } catch (error) {
+      throw new Error(
+        `Cannot open configuration file at \`${path.resolve("./config.json")}\`. Check to ensure that it exists. Use config-sample.json as a starting point.`
+      );
+    }
+    try {
+      config = Object.assign(JSON.parse(data), argv2);
+      console.log("Using configuration from ./config.json");
+    } catch (error) {
+      throw new Error(
+        `Cannot parse configuration file at \`${path.resolve("./config.json")}\`. Check to ensure that it is valid JSON.`
+      );
+    }
+  } else {
+    throw new Error(
+      "Cannot find configuration file. Use config-sample.json as a starting point, pass --configPath option."
+    );
+  }
+  return config;
+}
+async function unzip(zipfilePath, exportPath) {
+  const zip = new StreamZip.async({ file: zipfilePath });
+  await zip.extract(null, exportPath);
+  await zip.close();
+}
+
+// src/lib/log-utils.ts
+import { clearLine, cursorTo } from "node:readline";
+import { noop } from "lodash-es";
+import * as colors from "yoctocolors";
+function log(config) {
+  if (config.verbose === false) {
+    return noop;
+  }
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text, overwrite) => {
+    if (overwrite === true && process.stdout.isTTY) {
+      clearLine(process.stdout, 0);
+      cursorTo(process.stdout, 0);
+    } else {
+      process.stdout.write("\n");
+    }
+    process.stdout.write(text);
+  };
+}
+function logWarning(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatWarning(text)}
+`);
+  };
+}
+function logError(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatError(text)}
+`);
+  };
+}
+function formatWarning(text) {
+  const warningMessage = `${colors.underline("Warning")}: ${text}`;
+  return colors.yellow(warningMessage);
+}
+function formatError(error) {
+  const messageText = error instanceof Error ? error.message : error;
+  const errorMessage = `${colors.underline("Error")}: ${messageText.replace(
+    "Error: ",
+    ""
+  )}`;
+  return colors.red(errorMessage);
+}
+
+// src/lib/import.ts
+import path2 from "node:path";
+import { createReadStream, existsSync as existsSync2, lstatSync } from "node:fs";
+import { cp, readdir, rename, readFile as readFile2, rm as rm2, writeFile } from "node:fs/promises";
+import { parse } from "csv-parse";
+import pluralize from "pluralize";
+import stripBomStream from "strip-bom-stream";
+import { temporaryDirectory } from "tempy";
+import untildify3 from "untildify";
+import mapSeries from "promise-map-series";
+import GtfsRealtimeBindings from "gtfs-realtime-bindings";
+import sqlString2 from "sqlstring-sqlite";
+
+// src/models/gtfs/agency.ts
+var model = {
+  filenameBase: "agency",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "agency_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "agency_name",
+      type: "text",
+      required: true,
+      nocase: true
+    },
+    {
+      name: "agency_url",
+      type: "text",
+      required: true
+    },
+    {
+      name: "agency_timezone",
+      type: "text",
+      required: true
+    },
+    {
+      name: "agency_lang",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "agency_phone",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "agency_fare_url",
+      type: "text"
+    },
+    {
+      name: "agency_email",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var agency_default = model;
+
+// src/models/gtfs/areas.ts
+var model2 = {
+  filenameBase: "areas",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "area_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "area_name",
+      type: "text"
+    }
+  ]
+};
+var areas_default = model2;
+
+// src/models/gtfs/attributions.ts
+var model3 = {
+  filenameBase: "attributions",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "attribution_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "agency_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "organization_name",
+      type: "text",
+      required: true,
+      nocase: true
+    },
+    {
+      name: "is_producer",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "is_operator",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "is_authority",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "attribution_url",
+      type: "text"
+    },
+    {
+      name: "attribution_email",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "attribution_phone",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var attributions_default = model3;
+
+// src/models/gtfs/booking-rules.ts
+var model4 = {
+  filenameBase: "booking_rules",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "booking_rule_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "booking_type",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 2
+    },
+    {
+      name: "prior_notice_duration_min",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "prior_notice_duration_max",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "prior_notice_last_day",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "prior_notice_last_time",
+      type: "text"
+    },
+    {
+      name: "prior_notice_last_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "prior_notice_start_day",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "prior_notice_start_time",
+      type: "text"
+    },
+    {
+      name: "prior_notice_start_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "prior_notice_service_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "message",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "pickup_message",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "drop_off_message",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "phone_number",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "info_url",
+      type: "text"
+    },
+    {
+      name: "booking_url",
+      type: "text"
+    }
+  ]
+};
+var booking_rules_default = model4;
+
+// src/models/gtfs/calendar-dates.ts
+var model5 = {
+  filenameBase: "calendar_dates",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "service_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "date",
+      type: "integer",
+      required: true,
+      primary: true
+    },
+    {
+      name: "exception_type",
+      type: "integer",
+      required: true,
+      min: 1,
+      max: 2,
+      index: true
+    },
+    {
+      name: "holiday_name",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var calendar_dates_default = model5;
+
+// src/models/gtfs/calendar.ts
+var model6 = {
+  filenameBase: "calendar",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "service_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "monday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "tuesday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "wednesday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "thursday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "friday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "saturday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "sunday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "start_date",
+      type: "integer",
+      required: true,
+      index: true
+    },
+    {
+      name: "end_date",
+      type: "integer",
+      required: true,
+      index: true
+    }
+  ]
+};
+var calendar_default = model6;
+
+// src/models/gtfs/fare-attributes.ts
+var model7 = {
+  filenameBase: "fare_attributes",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "fare_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "price",
+      type: "real",
+      required: true
+    },
+    {
+      name: "currency_type",
+      type: "text",
+      required: true
+    },
+    {
+      name: "payment_method",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "transfers",
+      type: "integer",
+      min: 0,
+      max: 2
+    },
+    {
+      name: "agency_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "transfer_duration",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+var fare_attributes_default = model7;
+
+// src/models/gtfs/fare-leg-rules.ts
+var model8 = {
+  filenameBase: "fare_leg_rules",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "leg_group_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "network_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "from_area_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_area_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "from_timeframe_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_timeframe_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "fare_product_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "rule_priority",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+var fare_leg_rules_default = model8;
+
+// src/models/gtfs/fare-media.ts
+var model9 = {
+  filenameBase: "fare_media",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "fare_media_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "fare_media_name",
+      type: "text"
+    },
+    {
+      name: "fare_media_type",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 4
+    }
+  ]
+};
+var fare_media_default = model9;
+
+// src/models/gtfs/fare-products.ts
+var model10 = {
+  filenameBase: "fare_products",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "fare_product_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "fare_product_name",
+      type: "text"
+    },
+    {
+      name: "fare_media_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "amount",
+      type: "real",
+      required: true
+    },
+    {
+      name: "currency",
+      type: "text",
+      required: true
+    }
+  ]
+};
+var fare_products_default = model10;
+
+// src/models/gtfs/fare-rules.ts
+var model11 = {
+  filenameBase: "fare_rules",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "fare_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "origin_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "destination_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "contains_id",
+      type: "text",
+      prefix: true
+    }
+  ]
+};
+var fare_rules_default = model11;
+
+// src/models/gtfs/fare-transfer-rules.ts
+var model12 = {
+  filenameBase: "fare_transfer_rules",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "from_leg_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_leg_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "transfer_count",
+      type: "integer",
+      min: -1,
+      primary: true
+    },
+    {
+      name: "transfer_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "duration_limit",
+      type: "integer",
+      min: 0,
+      primary: true
+    },
+    {
+      name: "duration_limit_type",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "fare_transfer_type",
+      type: "integer",
+      min: 0,
+      max: 2,
+      required: true
+    },
+    {
+      name: "fare_product_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    }
+  ]
+};
+var fare_transfer_rules_default = model12;
+
+// src/models/gtfs/feed-info.ts
+var model13 = {
+  filenameBase: "feed_info",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "feed_publisher_name",
+      type: "text",
+      required: true,
+      nocase: true
+    },
+    {
+      name: "feed_publisher_url",
+      type: "text",
+      required: true
+    },
+    {
+      name: "feed_lang",
+      type: "text",
+      required: true
+    },
+    {
+      name: "default_lang",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "feed_start_date",
+      type: "integer"
+    },
+    {
+      name: "feed_end_date",
+      type: "integer"
+    },
+    {
+      name: "feed_version",
+      type: "text"
+    },
+    {
+      name: "feed_contact_email",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "feed_contact_url",
+      type: "text"
+    }
+  ]
+};
+var feed_info_default = model13;
+
+// src/models/gtfs/frequencies.ts
+var model14 = {
+  filenameBase: "frequencies",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "trip_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "start_time",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "start_timestamp",
+      type: "integer"
+    },
+    {
+      name: "end_time",
+      type: "text",
+      required: true
+    },
+    {
+      name: "end_timestamp",
+      type: "integer"
+    },
+    {
+      name: "headway_secs",
+      type: "integer",
+      required: true,
+      min: 0
+    },
+    {
+      name: "exact_times",
+      type: "integer",
+      min: 0,
+      max: 1
+    }
+  ]
+};
+var frequencies_default = model14;
+
+// src/models/gtfs/levels.ts
+var model15 = {
+  filenameBase: "levels",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "level_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "level_index",
+      type: "real",
+      required: true
+    },
+    {
+      name: "level_name",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var levels_default = model15;
+
+// src/models/gtfs/location-groups.ts
+var model16 = {
+  filenameBase: "location_groups",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "location_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "location_group_name",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var location_groups_default = model16;
+
+// src/models/gtfs/location-group-stops.ts
+var model17 = {
+  filenameBase: "location_group_stops",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "location_group_id",
+      type: "text",
+      prefix: true,
+      index: true,
+      required: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      prefix: true,
+      index: true
+    }
+  ]
+};
+var location_group_stops_default = model17;
+
+// src/models/gtfs/locations.ts
+var model18 = {
+  filenameBase: "locations",
+  filenameExtension: "geojson",
+  schema: [
+    {
+      name: "geojson",
+      type: "text"
+    }
+  ]
+};
+var locations_default = model18;
+
+// src/models/gtfs/networks.ts
+var model19 = {
+  filenameBase: "networks",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "network_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "network_name",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var networks_default = model19;
+
+// src/models/gtfs/pathways.ts
+var model20 = {
+  filenameBase: "pathways",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "pathway_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "from_stop_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "to_stop_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "pathway_mode",
+      type: "integer",
+      required: true,
+      min: 1,
+      max: 7
+    },
+    {
+      name: "is_bidirectional",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "length",
+      type: "real",
+      min: 0
+    },
+    {
+      name: "traversal_time",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "stair_count",
+      type: "integer"
+    },
+    {
+      name: "max_slope",
+      type: "real"
+    },
+    {
+      name: "min_width",
+      type: "real",
+      min: 0
+    },
+    {
+      name: "signposted_as",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "reversed_signposted_as",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var pathways_default = model20;
+
+// src/models/gtfs/route-networks.ts
+var model21 = {
+  filenameBase: "route_networks",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "network_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      primary: true,
+      index: true,
+      prefix: true
+    }
+  ]
+};
+var route_networks_default = model21;
+
+// src/models/gtfs/routes.ts
+var model22 = {
+  filenameBase: "routes",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "route_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "agency_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "route_short_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "route_long_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "route_desc",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "route_type",
+      type: "integer",
+      required: true,
+      min: 0
+      // Support extended GTFS route types with no max value
+      // https://developers.google.com/transit/gtfs/reference/extended-route-types
+    },
+    {
+      name: "route_url",
+      type: "text"
+    },
+    {
+      name: "route_color",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "route_text_color",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "route_sort_order",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "continuous_pickup",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "continuous_drop_off",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "network_id",
+      type: "text",
+      prefix: true
+    }
+  ]
+};
+var routes_default = model22;
+
+// src/models/gtfs/shapes.ts
+var model23 = {
+  filenameBase: "shapes",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "shape_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "shape_pt_lat",
+      type: "real",
+      required: true,
+      min: -90,
+      max: 90
+    },
+    {
+      name: "shape_pt_lon",
+      type: "real",
+      required: true,
+      min: -180,
+      max: 180
+    },
+    {
+      name: "shape_pt_sequence",
+      type: "integer",
+      required: true,
+      primary: true,
+      min: 0
+    },
+    {
+      name: "shape_dist_traveled",
+      type: "real",
+      min: 0
+    }
+  ]
+};
+var shapes_default = model23;
+
+// src/models/gtfs/stop-areas.ts
+var model24 = {
+  filenameBase: "stop_areas",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "area_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      prefix: true
+    }
+  ]
+};
+var stop_areas_default = model24;
+
+// src/models/gtfs/stop-times.ts
+var model25 = {
+  filenameBase: "stop_times",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "trip_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "arrival_time",
+      type: "text"
+    },
+    {
+      name: "arrival_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "departure_time",
+      type: "text"
+    },
+    {
+      name: "departure_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "location_group_id",
+      type: "text",
+      prefix: true,
+      index: true
+    },
+    {
+      name: "location_id",
+      type: "text",
+      prefix: true,
+      index: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      prefix: true,
+      index: true
+    },
+    {
+      name: "stop_sequence",
+      type: "integer",
+      required: true,
+      primary: true,
+      min: 0
+    },
+    {
+      name: "stop_headsign",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "start_pickup_drop_off_window",
+      type: "text"
+    },
+    {
+      name: "start_pickup_drop_off_window_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "pickup_type",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "drop_off_type",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "continuous_pickup",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "continuous_drop_off",
+      type: "integer",
+      min: 0,
+      max: 3
+    },
+    {
+      name: "shape_dist_traveled",
+      type: "real",
+      min: 0
+    },
+    {
+      name: "timepoint",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "pickup_booking_rule_id",
+      type: "text",
+      prefix: true,
+      index: true
+    },
+    {
+      name: "drop_off_booking_rule_id",
+      type: "text",
+      prefix: true,
+      index: true
+    }
+  ]
+};
+var stop_times_default = model25;
+
+// src/models/gtfs/stops.ts
+var model26 = {
+  filenameBase: "stops",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "stop_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "stop_code",
+      type: "text"
+    },
+    {
+      name: "stop_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "tts_stop_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "stop_desc",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "stop_lat",
+      type: "real",
+      min: -90,
+      max: 90
+    },
+    {
+      name: "stop_lon",
+      type: "real",
+      min: -180,
+      max: 180
+    },
+    {
+      name: "zone_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "stop_url",
+      type: "text"
+    },
+    {
+      name: "location_type",
+      type: "integer",
+      min: 0,
+      max: 4
+    },
+    {
+      name: "parent_station",
+      type: "text",
+      index: true
+    },
+    {
+      name: "stop_timezone",
+      type: "text"
+    },
+    {
+      name: "wheelchair_boarding",
+      type: "integer",
+      min: 0,
+      max: 2
+    },
+    {
+      name: "level_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "platform_code",
+      type: "text"
+    }
+  ]
+};
+var stops_default = model26;
+
+// src/models/gtfs/timeframes.ts
+var model27 = {
+  filenameBase: "timeframes",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "timeframe_group_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "start_time",
+      type: "text"
+    },
+    {
+      name: "end_time",
+      type: "text"
+    },
+    {
+      name: "service_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    }
+  ]
+};
+var timeframes_default = model27;
+
+// src/models/gtfs/transfers.ts
+var model28 = {
+  filenameBase: "transfers",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "from_stop_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_stop_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "from_route_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_route_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "from_trip_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "to_trip_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "transfer_type",
+      type: "integer",
+      min: 0,
+      max: 5,
+      default: 0
+    },
+    {
+      name: "min_transfer_time",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+var transfers_default = model28;
+
+// src/models/gtfs/translations.ts
+var model29 = {
+  filenameBase: "translations",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "table_name",
+      type: "text",
+      primary: true,
+      required: true
+    },
+    {
+      name: "field_name",
+      type: "text",
+      primary: true,
+      required: true
+    },
+    {
+      name: "language",
+      type: "text",
+      primary: true,
+      required: true
+    },
+    {
+      name: "translation",
+      type: "text",
+      required: true
+    },
+    {
+      name: "record_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "record_sub_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "field_value",
+      type: "text",
+      primary: true
+    }
+  ]
+};
+var translations_default = model29;
+
+// src/models/gtfs/trips.ts
+var model30 = {
+  filenameBase: "trips",
+  filenameExtension: "txt",
+  schema: [
+    {
+      name: "route_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "service_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "trip_headsign",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "trip_short_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      min: 0,
+      max: 1,
+      index: true
+    },
+    {
+      name: "block_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "shape_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "wheelchair_accessible",
+      type: "integer",
+      min: 0,
+      max: 2
+    },
+    {
+      name: "bikes_allowed",
+      type: "integer",
+      min: 0,
+      max: 2
+    }
+  ]
+};
+var trips_default = model30;
+
+// src/models/non-standard/timetables.ts
+var model31 = {
+  filenameBase: "timetables",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "id",
+      type: "integer",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "timetable_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "start_date",
+      type: "integer"
+    },
+    {
+      name: "end_date",
+      type: "integer"
+    },
+    {
+      name: "monday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "tuesday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "wednesday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "thursday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "friday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "saturday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "sunday",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1
+    },
+    {
+      name: "start_time",
+      type: "text"
+    },
+    {
+      name: "start_timestamp",
+      type: "integer"
+    },
+    {
+      name: "end_time",
+      type: "text"
+    },
+    {
+      name: "end_timestamp",
+      type: "integer"
+    },
+    {
+      name: "timetable_label",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "service_notes",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "orientation",
+      type: "text"
+    },
+    {
+      name: "timetable_page_id",
+      type: "text"
+    },
+    {
+      name: "timetable_sequence",
+      type: "integer",
+      min: 0,
+      index: true
+    },
+    {
+      name: "direction_name",
+      type: "text"
+    },
+    {
+      name: "include_exceptions",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "show_trip_continuation",
+      type: "integer",
+      min: 0,
+      max: 1
+    }
+  ]
+};
+var timetables_default = model31;
+
+// src/models/non-standard/timetable-pages.ts
+var model32 = {
+  filenameBase: "timetable_pages",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "timetable_page_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "timetable_page_label",
+      type: "text"
+    },
+    {
+      name: "filename",
+      type: "text"
+    }
+  ]
+};
+var timetable_pages_default = model32;
+
+// src/models/non-standard/timetable-stop-order.ts
+var model33 = {
+  filenameBase: "timetable_stop_order",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "id",
+      type: "integer",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "timetable_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "stop_sequence",
+      type: "integer",
+      min: 0,
+      index: true
+    }
+  ]
+};
+var timetable_stop_order_default = model33;
+
+// src/models/non-standard/timetable-notes.ts
+var model34 = {
+  filenameBase: "timetable_notes",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "note_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "symbol",
+      type: "text"
+    },
+    {
+      name: "note",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var timetable_notes_default = model34;
+
+// src/models/non-standard/timetable-notes-references.ts
+var model35 = {
+  filenameBase: "timetable_notes_references",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "note_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "timetable_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "stop_sequence",
+      type: "integer",
+      min: 0,
+      index: true
+    },
+    {
+      name: "show_on_stoptime",
+      type: "integer",
+      min: 0,
+      max: 1
+    }
+  ]
+};
+var timetable_notes_references_default = model35;
+
+// src/models/non-standard/trips-dated-vehicle-journey.ts
+var model36 = {
+  filenameBase: "trips_dated_vehicle_journeys",
+  filenameExtension: "txt",
+  nonstandard: true,
+  schema: [
+    {
+      name: "trip_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "operating_day_date",
+      type: "text",
+      index: true,
+      required: true
+    },
+    {
+      name: "dated_vehicle_journey_gid",
+      type: "text",
+      required: true
+    },
+    {
+      name: "journey_number",
+      type: "integer",
+      min: 0,
+      max: 65535,
+      index: true
+    }
+  ]
+};
+var trips_dated_vehicle_journey_default = model36;
+
+// src/models/gtfs-plus/calendar-attributes.ts
+var model37 = {
+  filenameBase: "calendar_attributes",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-plus",
+  schema: [
+    {
+      name: "service_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "service_description",
+      type: "text",
+      required: true,
+      nocase: true
+    }
+  ]
+};
+var calendar_attributes_default = model37;
+
+// src/models/gtfs-plus/directions.ts
+var model38 = {
+  filenameBase: "directions",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-plus",
+  schema: [
+    {
+      name: "route_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      min: 0,
+      max: 1,
+      primary: true
+    },
+    {
+      name: "direction",
+      type: "text",
+      required: true
+    }
+  ]
+};
+var directions_default = model38;
+
+// src/models/gtfs-plus/route-attributes.ts
+var model39 = {
+  filenameBase: "route_attributes",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-plus",
+  schema: [
+    {
+      name: "route_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "category",
+      type: "integer",
+      min: 0,
+      required: true
+    },
+    {
+      name: "subcategory",
+      type: "integer",
+      min: 101,
+      required: true
+    },
+    {
+      name: "running_way",
+      type: "integer",
+      min: 1,
+      required: true
+    }
+  ]
+};
+var route_attributes_default = model39;
+
+// src/models/gtfs-plus/stop-attributes.ts
+var model40 = {
+  filenameBase: "stop_attributes",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-plus",
+  schema: [
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "accessibility_id",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "cardinal_direction",
+      type: "text"
+    },
+    {
+      name: "relative_position",
+      type: "text"
+    },
+    {
+      name: "stop_city",
+      type: "text",
+      nocase: true
+    }
+  ]
+};
+var stop_attributes_default = model40;
+
+// src/models/gtfs-ride/board-alight.ts
+var model41 = {
+  filenameBase: "board_alight",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-ride",
+  schema: [
+    {
+      name: "trip_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "stop_sequence",
+      type: "integer",
+      required: true,
+      min: 0,
+      index: true
+    },
+    {
+      name: "record_use",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 1,
+      index: true
+    },
+    {
+      name: "schedule_relationship",
+      type: "integer",
+      min: 0,
+      max: 8
+    },
+    {
+      name: "boardings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "alightings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "current_load",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "load_count",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "load_type",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "rack_down",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "bike_boardings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_alightings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "ramp_used",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "ramp_boardings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "ramp_alightings",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "service_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "service_arrival_time",
+      type: "text"
+    },
+    {
+      name: "service_arrival_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "service_departure_time",
+      type: "text"
+    },
+    {
+      name: "service_departure_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "source",
+      type: "integer",
+      min: 0,
+      max: 4
+    }
+  ]
+};
+var board_alight_default = model41;
+
+// src/models/gtfs-ride/rider-trip.ts
+var model42 = {
+  filenameBase: "rider_trip",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-ride",
+  schema: [
+    {
+      name: "rider_id",
+      type: "text",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "agency_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "boarding_stop_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "boarding_stop_sequence",
+      type: "integer",
+      min: 0,
+      index: true
+    },
+    {
+      name: "alighting_stop_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "alighting_stop_sequence",
+      type: "integer",
+      min: 0,
+      index: true
+    },
+    {
+      name: "service_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "boarding_time",
+      type: "text"
+    },
+    {
+      name: "boarding_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "alighting_time",
+      type: "text"
+    },
+    {
+      name: "alighting_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "rider_type",
+      type: "integer",
+      min: 0,
+      max: 13
+    },
+    {
+      name: "rider_type_description",
+      type: "text"
+    },
+    {
+      name: "fare_paid",
+      type: "real"
+    },
+    {
+      name: "transaction_type",
+      type: "integer",
+      min: 0,
+      max: 8
+    },
+    {
+      name: "fare_media",
+      type: "integer",
+      min: 0,
+      max: 9
+    },
+    {
+      name: "accompanying_device",
+      type: "integer",
+      min: 0,
+      max: 6
+    },
+    {
+      name: "transfer_status",
+      type: "integer",
+      min: 0,
+      max: 1
+    }
+  ]
+};
+var rider_trip_default = model42;
+
+// src/models/gtfs-ride/ridership.ts
+var model43 = {
+  filenameBase: "ridership",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-ride",
+  schema: [
+    {
+      name: "total_boardings",
+      type: "integer",
+      min: 0,
+      required: true
+    },
+    {
+      name: "total_alightings",
+      type: "integer",
+      min: 0,
+      required: true
+    },
+    {
+      name: "ridership_start_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "ridership_end_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "ridership_start_time",
+      type: "text"
+    },
+    {
+      name: "ridership_start_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "ridership_end_time",
+      type: "text"
+    },
+    {
+      name: "ridership_end_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "service_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "monday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "tuesday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "wednesday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "thursday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "friday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "saturday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "sunday",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "agency_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "route_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      min: 0,
+      max: 1,
+      index: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      prefix: true
+    }
+  ]
+};
+var ridership_default = model43;
+
+// src/models/gtfs-ride/trip-capacity.ts
+var model44 = {
+  filenameBase: "trip_capacity",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-ride",
+  schema: [
+    {
+      name: "agency_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "service_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "vehicle_description",
+      type: "text"
+    },
+    {
+      name: "seated_capacity",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "standing_capacity",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "wheelchair_capacity",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_capacity",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+var trip_capacity_default = model44;
+
+// src/models/gtfs-ride/ride-feed-info.ts
+var model45 = {
+  filenameBase: "ride_feed_info",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "gtfs-ride",
+  schema: [
+    {
+      name: "ride_files",
+      type: "integer",
+      min: 0,
+      max: 6,
+      required: true
+    },
+    {
+      name: "ride_start_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "ride_end_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "gtfs_feed_date",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "default_currency_type",
+      type: "text"
+    },
+    {
+      name: "ride_feed_version",
+      type: "text"
+    }
+  ]
+};
+var ride_feed_info_default = model45;
+
+// src/models/gtfs-realtime/trip-updates.ts
+var model46 = {
+  filenameBase: "trip_updates",
+  extension: "gtfs-realtime",
+  schema: [
+    {
+      name: "update_id",
+      type: "text",
+      required: true,
+      primary: true,
+      index: true,
+      source: "id"
+    },
+    {
+      name: "vehicle_id",
+      type: "text",
+      index: true,
+      source: "tripUpdate.vehicle.id",
+      default: null
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      source: "tripUpdate.trip.tripId",
+      default: null
+    },
+    {
+      name: "trip_start_time",
+      type: "text",
+      source: "tripUpdate.trip.startTime",
+      default: null
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      source: "tripUpdate.trip.directionId",
+      default: null
+    },
+    {
+      name: "route_id",
+      type: "text",
+      index: true,
+      source: "tripUpdate.trip.routeId",
+      default: null
+    },
+    {
+      name: "start_date",
+      type: "text",
+      source: "tripUpdate.trip.startDate",
+      default: null
+    },
+    {
+      name: "timestamp",
+      type: "text",
+      source: "tripUpdate.timestamp",
+      default: null
+    },
+    {
+      name: "schedule_relationship",
+      type: "text",
+      source: "tripUpdate.trip.scheduleRelationship",
+      default: null
+    },
+    {
+      name: "created_timestamp",
+      type: "integer",
+      required: true
+    },
+    {
+      name: "expiration_timestamp",
+      type: "integer",
+      required: true
+    }
+  ]
+};
+var trip_updates_default = model46;
+
+// src/models/gtfs-realtime/stop-time-updates.ts
+var model47 = {
+  filenameBase: "stop_time_updates",
+  extension: "gtfs-realtime",
+  schema: [
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      source: "parent.tripUpdate.trip.tripId",
+      default: null
+    },
+    {
+      name: "trip_start_time",
+      type: "text",
+      source: "parent.tripUpdate.trip.startTime",
+      default: null
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      source: "parent.tripUpdate.trip.directionId",
+      default: null
+    },
+    {
+      name: "route_id",
+      type: "text",
+      index: true,
+      source: "parent.tripUpdate.trip.routeId",
+      default: null
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      index: true,
+      source: "stopId",
+      default: null
+    },
+    {
+      name: "stop_sequence",
+      type: "integer",
+      source: "stopSequence",
+      default: null
+    },
+    {
+      name: "arrival_delay",
+      type: "integer",
+      source: "arrival.delay",
+      default: null
+    },
+    {
+      name: "departure_delay",
+      type: "integer",
+      source: "departure.delay",
+      default: null
+    },
+    {
+      name: "departure_timestamp",
+      type: "text",
+      source: "departure.time",
+      default: null
+    },
+    {
+      name: "arrival_timestamp",
+      type: "text",
+      source: "arrival.time",
+      default: null
+    },
+    {
+      name: "schedule_relationship",
+      type: "text",
+      source: "scheduleRelationship",
+      default: null
+    },
+    {
+      name: "created_timestamp",
+      type: "integer",
+      required: true
+    },
+    {
+      name: "expiration_timestamp",
+      type: "integer",
+      required: true
+    }
+  ]
+};
+var stop_time_updates_default = model47;
+
+// src/models/gtfs-realtime/vehicle-positions.ts
+var model48 = {
+  filenameBase: "vehicle_positions",
+  extension: "gtfs-realtime",
+  schema: [
+    {
+      name: "update_id",
+      type: "text",
+      required: true,
+      primary: true,
+      index: true,
+      source: "id"
+    },
+    {
+      name: "bearing",
+      type: "real",
+      source: "vehicle.position.bearing",
+      default: null
+    },
+    {
+      name: "latitude",
+      type: "real",
+      min: -90,
+      max: 90,
+      source: "vehicle.position.latitude",
+      default: null
+    },
+    {
+      name: "longitude",
+      type: "real",
+      source: "vehicle.position.longitude",
+      min: -180,
+      max: 180,
+      default: null
+    },
+    {
+      name: "speed",
+      type: "real",
+      min: 0,
+      source: "vehicle.position.speed",
+      default: null
+    },
+    {
+      name: "current_stop_sequence",
+      type: "integer",
+      source: "vehicle.currentStopSequence",
+      default: null
+    },
+    {
+      name: "trip_id",
+      type: "text",
+      index: true,
+      source: "vehicle.trip.tripId",
+      default: null
+    },
+    {
+      name: "trip_start_date",
+      type: "text",
+      index: true,
+      source: "vehicle.trip.startDate",
+      default: null
+    },
+    {
+      name: "trip_start_time",
+      type: "text",
+      index: true,
+      source: "vehicle.trip.startTime",
+      default: null
+    },
+    {
+      name: "congestion_level",
+      type: "text",
+      source: "vehicle.congestionLevel",
+      default: null
+    },
+    {
+      name: "occupancy_status",
+      type: "text",
+      source: "vehicle.occupancyStatus",
+      default: null
+    },
+    {
+      name: "occupancy_percentage",
+      type: "integer",
+      source: "vehicle.occupancyPercentage",
+      default: null
+    },
+    {
+      name: "vehicle_stop_status",
+      type: "text",
+      source: "vehicle.vehicleStopStatus",
+      default: null
+    },
+    {
+      name: "vehicle_id",
+      type: "text",
+      index: true,
+      source: "vehicle.vehicle.id",
+      default: null
+    },
+    {
+      name: "vehicle_label",
+      type: "text",
+      source: "vehicle.vehicle.label",
+      default: null
+    },
+    {
+      name: "vehicle_license_plate",
+      type: "text",
+      source: "vehicle.vehicle.licensePlate",
+      default: null
+    },
+    {
+      name: "vehicle_wheelchair_accessible",
+      type: "text",
+      source: "vehicle.vehicle.wheelchairAccessible",
+      default: null
+    },
+    {
+      name: "timestamp",
+      type: "text",
+      source: "vehicle.timestamp",
+      default: null
+    },
+    {
+      name: "created_timestamp",
+      type: "integer",
+      required: true
+    },
+    {
+      name: "expiration_timestamp",
+      type: "integer",
+      required: true
+    }
+  ]
+};
+var vehicle_positions_default = model48;
+
+// src/models/gtfs-realtime/service-alerts.ts
+var model49 = {
+  filenameBase: "service_alerts",
+  extension: "gtfs-realtime",
+  schema: [
+    {
+      name: "id",
+      type: "text",
+      required: true,
+      primary: true,
+      index: true,
+      source: "id"
+    },
+    {
+      name: "cause",
+      type: "integer",
+      required: true,
+      min: 0,
+      source: "alert.cause",
+      default: 0
+    },
+    {
+      name: "start_time",
+      type: "text",
+      required: true,
+      source: "alert.activePeriod[0].start",
+      default: ""
+    },
+    {
+      name: "end_time",
+      type: "text",
+      required: true,
+      source: "alert.activePeriod[0].end",
+      default: ""
+    },
+    {
+      name: "headline",
+      type: "text",
+      required: true,
+      source: "alert.headerText.translation[0].text",
+      default: ""
+    },
+    {
+      name: "description",
+      type: "text",
+      required: true,
+      source: "alert.descriptionText.translation[0].text",
+      default: ""
+    },
+    {
+      name: "created_timestamp",
+      type: "integer",
+      required: true
+    },
+    {
+      name: "expiration_timestamp",
+      type: "integer",
+      required: true
+    }
+  ]
+};
+var service_alerts_default = model49;
+
+// src/models/gtfs-realtime/service-alert-targets.ts
+var model50 = {
+  filenameBase: "service_alert_targets",
+  extension: "gtfs-realtime",
+  schema: [
+    {
+      name: "alert_id",
+      type: "text",
+      required: true,
+      primary: true,
+      source: "parent.id"
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      index: true,
+      source: "stopId",
+      default: null
+    },
+    {
+      name: "route_id",
+      type: "text",
+      index: true,
+      source: "routeId",
+      default: null
+    },
+    {
+      name: "created_timestamp",
+      type: "integer",
+      required: true
+    },
+    {
+      name: "expiration_timestamp",
+      type: "integer",
+      required: true
+    }
+  ]
+};
+var service_alert_targets_default = model50;
+
+// src/models/ods/deadhead-times.ts
+var model51 = {
+  filenameBase: "deadhead_times",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "ods",
+  schema: [
+    {
+      name: "id",
+      type: "integer",
+      primary: true,
+      prefix: true
+    },
+    {
+      name: "deadhead_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "arrival_time",
+      type: "text",
+      required: true
+    },
+    {
+      name: "arrival_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "departure_time",
+      type: "text",
+      required: true
+    },
+    {
+      name: "departure_timestamp",
+      type: "integer",
+      index: true
+    },
+    {
+      name: "ops_location_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "location_sequence",
+      type: "integer",
+      required: true,
+      min: 0,
+      index: true
+    },
+    {
+      name: "shape_dist_traveled",
+      type: "real",
+      min: 0
+    }
+  ]
+};
+var deadhead_times_default = model51;
+
+// src/models/ods/deadheads.ts
+var model52 = {
+  filenameBase: "deadheads",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "ods",
+  schema: [
+    {
+      name: "deadhead_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "service_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "block_id",
+      type: "text",
+      required: true,
+      index: true,
+      prefix: true
+    },
+    {
+      name: "shape_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "to_trip_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "from_trip_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "to_deadhead_id",
+      type: "text",
+      index: true,
+      prefix: true
+    },
+    {
+      name: "from_deadhead_id",
+      type: "text",
+      index: true,
+      prefix: true
+    }
+  ]
+};
+var deadheads_default = model52;
+
+// src/models/ods/ops-locations.ts
+var model53 = {
+  filenameBase: "ops_locations",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "ods",
+  schema: [
+    {
+      name: "ops_location_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "ops_location_code",
+      type: "text"
+    },
+    {
+      name: "ops_location_name",
+      type: "text",
+      required: true,
+      nocase: true
+    },
+    {
+      name: "ops_location_desc",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "ops_location_lat",
+      type: "real",
+      required: true,
+      min: -90,
+      max: 90
+    },
+    {
+      name: "ops_location_lon",
+      type: "real",
+      required: true,
+      min: -180,
+      max: 180
+    }
+  ]
+};
+var ops_locations_default = model53;
+
+// src/models/ods/run-events.ts
+var model54 = {
+  filenameBase: "run_event",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "ods",
+  schema: [
+    {
+      name: "run_event_id",
+      type: "text",
+      primary: true,
+      required: true,
+      prefix: true
+    },
+    {
+      name: "piece_id",
+      type: "text",
+      required: true,
+      prefix: true
+    },
+    {
+      name: "event_type",
+      type: "integer",
+      required: true,
+      min: 0,
+      index: true
+    },
+    {
+      name: "event_name",
+      type: "text",
+      nocase: true
+    },
+    {
+      name: "event_time",
+      type: "text",
+      required: true
+    },
+    {
+      name: "event_duration",
+      type: "integer",
+      required: true,
+      min: 0
+    },
+    {
+      name: "event_from_location_type",
+      type: "integer",
+      min: 0,
+      max: 1,
+      index: true
+    },
+    {
+      name: "event_from_location_id",
+      type: "text",
+      prefix: true
+    },
+    {
+      name: "event_to_location_type",
+      type: "integer",
+      min: 0,
+      max: 1,
+      index: true
+    },
+    {
+      name: "event_to_location_id",
+      type: "text",
+      prefix: true
+    }
+  ]
+};
+var run_events_default = model54;
+
+// src/models/ods/runs-pieces.ts
+var model55 = {
+  filenameBase: "runs_pieces",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "ods",
+  schema: [
+    {
+      name: "run_id",
+      type: "text",
+      required: true
+    },
+    {
+      name: "piece_id",
+      type: "text",
+      primary: true,
+      required: true
+    },
+    {
+      name: "start_type",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 2,
+      index: true
+    },
+    {
+      name: "start_trip_id",
+      type: "text",
+      required: true,
+      index: true
+    },
+    {
+      name: "start_trip_position",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "end_type",
+      type: "integer",
+      required: true,
+      min: 0,
+      max: 2,
+      index: true
+    },
+    {
+      name: "end_trip_id",
+      type: "text",
+      required: true,
+      index: true
+    },
+    {
+      name: "end_trip_position",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+var runs_pieces_default = model55;
+
+// src/models/models.ts
+var models = [
+  agency_default,
+  areas_default,
+  attributions_default,
+  booking_rules_default,
+  calendar_dates_default,
+  calendar_default,
+  fare_attributes_default,
+  fare_leg_rules_default,
+  fare_media_default,
+  fare_products_default,
+  fare_rules_default,
+  fare_transfer_rules_default,
+  feed_info_default,
+  frequencies_default,
+  levels_default,
+  location_groups_default,
+  location_group_stops_default,
+  locations_default,
+  networks_default,
+  pathways_default,
+  route_networks_default,
+  routes_default,
+  shapes_default,
+  stop_areas_default,
+  stop_times_default,
+  stops_default,
+  timeframes_default,
+  transfers_default,
+  translations_default,
+  trips_default,
+  timetables_default,
+  timetable_pages_default,
+  timetable_stop_order_default,
+  timetable_notes_default,
+  timetable_notes_references_default,
+  trips_dated_vehicle_journey_default,
+  calendar_attributes_default,
+  directions_default,
+  route_attributes_default,
+  stop_attributes_default,
+  board_alight_default,
+  ride_feed_info_default,
+  rider_trip_default,
+  ridership_default,
+  trip_capacity_default,
+  trip_updates_default,
+  stop_time_updates_default,
+  vehicle_positions_default,
+  service_alerts_default,
+  service_alert_targets_default,
+  deadhead_times_default,
+  deadheads_default,
+  ops_locations_default,
+  run_events_default,
+  runs_pieces_default
+];
+var models_default = models;
+
+// src/lib/db.ts
+import Database from "better-sqlite3";
+import untildify2 from "untildify";
+
+// src/lib/utils.ts
+import sqlString from "sqlstring-sqlite";
+import Long from "long";
+function validateConfigForImport(config) {
+  if (!config.agencies || config.agencies.length === 0) {
+    throw new Error("No `agencies` specified in config");
+  }
+  for (const [index, agency] of config.agencies.entries()) {
+    if (!agency.path && !agency.url) {
+      throw new Error(
+        `No Agency \`url\` or \`path\` specified in config for agency index ${index}.`
+      );
+    }
+  }
+  return config;
+}
+function setDefaultConfig(initialConfig) {
+  const defaults = {
+    sqlitePath: ":memory:",
+    ignoreDuplicates: false,
+    gtfsRealtimeExpirationSeconds: 0
+  };
+  return {
+    ...defaults,
+    ...initialConfig
+  };
+}
+function convertLongTimeToDate(longDate) {
+  const { high, low, unsigned } = longDate;
+  return new Date(new Long(low, high, unsigned).toInt() * 1e3).toISOString();
+}
+function calculateSecondsFromMidnight(time) {
+  const split = time.split(":").map((d) => Number.parseInt(d, 10));
+  if (split.length !== 3) {
+    return null;
+  }
+  return split[0] * 3600 + split[1] * 60 + split[2];
+}
+function padLeadingZeros(time) {
+  const split = time.split(":").map((d) => String(Number(d)).padStart(2, "0"));
+  if (split.length !== 3) {
+    return null;
+  }
+  return split.join(":");
+}
+
+// src/lib/db.ts
+var dbs = {};
+function setupDb(sqlitePath) {
+  const db = new Database(untildify2(sqlitePath));
+  db.pragma("journal_mode = OFF");
+  db.pragma("synchronous = OFF");
+  db.pragma("temp_store = MEMORY");
+  dbs[sqlitePath] = db;
+  return db;
+}
+function openDb(config = null) {
+  if (config) {
+    const { sqlitePath, db } = setDefaultConfig(config);
+    if (db) {
+      return db;
+    }
+    if (dbs[sqlitePath]) {
+      return dbs[sqlitePath];
+    }
+    return setupDb(sqlitePath);
+  }
+  if (Object.keys(dbs).length === 1) {
+    const filename = Object.keys(dbs)[0];
+    return dbs[filename];
+  }
+  if (Object.keys(dbs).length > 1) {
+    throw new Error(
+      "Multiple databases open, please specify which one to use."
+    );
+  }
+  throw new Error("Unable to find database connection.");
+}
+function closeDb(db = null) {
+  if (Object.keys(dbs).length === 0) {
+    throw new Error(
+      "No database connection. Call `openDb(config)` before using any methods."
+    );
+  }
+  if (!db) {
+    if (Object.keys(dbs).length > 1) {
+      throw new Error(
+        "Multiple database connections. Pass the db you want to close as a parameter to `closeDb`."
+      );
+    }
+    db = dbs[Object.keys(dbs)[0]];
+  }
+  db.close();
+  delete dbs[db.name];
+}
+
+// src/lib/geojson-utils.ts
+import {
+  cloneDeep,
+  filter,
+  groupBy,
+  last,
+  omit as omit2,
+  sortBy,
+  omitBy
+} from "lodash-es";
+import { feature, featureCollection } from "@turf/helpers";
+function isValidJSON(string) {
+  try {
+    JSON.parse(string);
+  } catch (error) {
+    return false;
+  }
+  return true;
+}
+
+// src/lib/import.ts
+var downloadFiles = async (task) => {
+  task.log(`Downloading GTFS from ${task.agency_url}`);
+  task.path = `${task.downloadDir}/gtfs.zip`;
+  const response = await fetch(task.agency_url, {
+    method: "GET",
+    headers: task.headers || {},
+    signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
+  });
+  if (response.status !== 200) {
+    throw new Error(`Unable to download GTFS from ${task.agency_url}`);
+  }
+  const buffer = await response.arrayBuffer();
+  await writeFile(task.path, Buffer.from(buffer));
+  task.log("Download successful");
+};
+var downloadGtfsRealtimeData = async (url, task) => {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      ...task.realtime_headers || {},
+      "Accept-Encoding": "gzip"
+    },
+    signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
+  });
+  if (response.status !== 200) {
+    task.logWarning(`Unable to download GTFS-Realtime from ${url}`);
+    return null;
+  }
+  const buffer = await response.arrayBuffer();
+  const message = GtfsRealtimeBindings.transit_realtime.FeedMessage.decode(
+    new Uint8Array(buffer)
+  );
+  return GtfsRealtimeBindings.transit_realtime.FeedMessage.toObject(message, {
+    enums: String,
+    longs: String,
+    bytes: String,
+    defaults: true,
+    arrays: true,
+    objects: true,
+    oneofs: true
+  });
+};
+function getDescendantProp(obj, defaultValue, source) {
+  if (source === void 0) return defaultValue;
+  const arr = source.split(".");
+  while (arr.length) {
+    const nextKey = arr.shift();
+    if (nextKey === void 0) {
+      return defaultValue;
+    } else if (obj == null) {
+      return defaultValue;
+    } else if (nextKey?.includes("[")) {
+      const arrayKey = nextKey.match(/(\w*)\[(\d+)\]/);
+      if (arrayKey === null) {
+        return defaultValue;
+      }
+      if (obj[arrayKey[1]] === void 0) {
+        return defaultValue;
+      }
+      if (obj[arrayKey[1]][arrayKey[2]] === void 0) {
+        return defaultValue;
+      }
+      obj = obj[arrayKey[1]][arrayKey[2]];
+    } else {
+      if (obj[nextKey] === void 0) {
+        return defaultValue;
+      }
+      obj = obj[nextKey];
+    }
+  }
+  if (obj.__isLong__) return convertLongTimeToDate(obj);
+  return obj;
+}
+var prepareRealtimeValue = (entity, column, task) => {
+  if (column.name === "created_timestamp") {
+    return task.currentTimestamp;
+  }
+  if (column.name === "expiration_timestamp") {
+    return task.currentTimestamp + task.gtfsRealtimeExpirationSeconds;
+  }
+  return sqlString2.escape(
+    getDescendantProp(entity, column.default, column.source)
+  );
+};
+var updateRealtimeData = async (task) => {
+  if (!task.realtime_urls) {
+    return;
+  }
+  const db = openDb({
+    sqlitePath: task.sqlitePath,
+    agencies: []
+  });
+  const vehiclePositionsModel = models_default.find(
+    (x) => x.filenameBase === "vehicle_positions"
+  );
+  const tripUpdatesModel = models_default.find(
+    (x) => x.filenameBase === "trip_updates"
+  );
+  const stoptimeUpdatesModel = models_default.find(
+    (x) => x.filenameBase === "stop_time_updates"
+  );
+  const serviceAlertsModel = models_default.find(
+    (x) => x.filenameBase === "service_alerts"
+  );
+  const serviceAlertTargetsModel = models_default.find(
+    (x) => x.filenameBase === "service_alert_targets"
+  );
+  if (!vehiclePositionsModel || !tripUpdatesModel || !stoptimeUpdatesModel || !serviceAlertsModel || !serviceAlertTargetsModel) {
+    task.logError("GTFS-Realtime models definitions not found");
+    return;
+  }
+  task.log(
+    `Starting GTFS-Realtime import from ${task.realtime_urls.length} urls`
+  );
+  for (const realtimeUrl of task.realtime_urls) {
+    task.log(`Downloading GTFS-Realtime from ${realtimeUrl}`);
+    const gtfsRealtimeData = await downloadGtfsRealtimeData(realtimeUrl, task);
+    if (!gtfsRealtimeData?.entity) {
+      continue;
+    }
+    task.log(`Download successful`);
+    let totalLineCount = 0;
+    for (const entity of gtfsRealtimeData.entity) {
+      let model56;
+      if (entity.vehicle) {
+        model56 = vehiclePositionsModel;
+      }
+      if (entity.tripUpdate) {
+        model56 = tripUpdatesModel;
+      }
+      if (entity.alert) {
+        model56 = serviceAlertsModel;
+      }
+      if (!model56) {
+        break;
+      }
+      const fieldValues = model56.schema.map(
+        (column) => prepareRealtimeValue(entity, column, task)
+      );
+      try {
+        db.prepare(
+          `REPLACE INTO ${model56.filenameBase} (${model56.schema.map((column) => column.name).join(", ")}) VALUES (${fieldValues.join(", ")})`
+        ).run();
+      } catch (error) {
+        task.logWarning("Import error: " + error.message);
+      }
+      if (entity.tripUpdate) {
+        const stopTimeUpdateArray = [];
+        for (const stopTimeUpdate of entity.tripUpdate.stopTimeUpdate) {
+          stopTimeUpdate.parent = entity;
+          const subValues = stoptimeUpdatesModel.schema.map(
+            (column) => prepareRealtimeValue(stopTimeUpdate, column, task)
+          );
+          stopTimeUpdateArray.push(`(${subValues.join(", ")})`);
+          totalLineCount++;
+        }
+        try {
+          db.prepare(
+            `REPLACE INTO ${stoptimeUpdatesModel.filenameBase} (${stoptimeUpdatesModel.schema.map((column) => column.name).join(", ")}) VALUES ${stopTimeUpdateArray.join(", ")}`
+          ).run();
+        } catch (error) {
+          task.logWarning("Import error: " + error.message);
+        }
+      }
+      if (entity.alert) {
+        const alertTargetArray = [];
+        for (const informedEntity of entity.alert.informedEntity) {
+          informedEntity.parent = entity;
+          const subValues = serviceAlertTargetsModel.schema.map(
+            (column) => prepareRealtimeValue(informedEntity, column, task)
+          );
+          alertTargetArray.push(`(${subValues.join(", ")})`);
+          totalLineCount++;
+        }
+        try {
+          db.prepare(
+            `REPLACE INTO ${serviceAlertTargetsModel.filenameBase} (${serviceAlertTargetsModel.schema.map((column) => column.name).join(", ")}) VALUES ${alertTargetArray.join(", ")}`
+          ).run();
+        } catch (error) {
+          task.logWarning("Import error: " + error.message);
+        }
+      }
+      task.log(`Importing - ${totalLineCount++} entries imported\r`, true);
+    }
+  }
+  task.log(`GTFS-Realtime data import complete`);
+};
+var getTextFiles = async (folderPath) => {
+  const files = await readdir(folderPath);
+  return files.filter((filename) => filename.slice(-3) === "txt");
+};
+var readFiles = async (task) => {
+  const gtfsPath = untildify3(task.path);
+  task.log(`Importing GTFS from ${task.path}\r`);
+  if (path2.extname(gtfsPath) === ".zip") {
+    try {
+      await unzip(gtfsPath, task.downloadDir);
+      const textFiles = await getTextFiles(task.downloadDir);
+      if (textFiles.length === 0) {
+        const files = await readdir(task.downloadDir);
+        const folders = files.filter((filename) => !["__MACOSX"].includes(filename)).map((filename) => path2.join(task.downloadDir, filename)).filter((source) => lstatSync(source).isDirectory());
+        if (folders.length > 1) {
+          throw new Error(
+            `More than one subfolder found in zip file at \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          );
+        } else if (folders.length === 0) {
+          throw new Error(
+            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          );
+        }
+        const subfolderName = folders[0];
+        const directoryTextFiles = await getTextFiles(subfolderName);
+        if (directoryTextFiles.length === 0) {
+          throw new Error(
+            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          );
+        }
+        await Promise.all(
+          directoryTextFiles.map(
+            async (fileName) => rename(
+              path2.join(subfolderName, fileName),
+              path2.join(task.downloadDir, fileName)
+            )
+          )
+        );
+      }
+    } catch (error) {
+      task.logError(error);
+      throw new Error(`Unable to unzip file ${task.path}`);
+    }
+  } else {
+    try {
+      await cp(gtfsPath, task.downloadDir, { recursive: true });
+    } catch {
+      throw new Error(
+        `Unable to load files from path \`${gtfsPath}\` defined in configuration. Verify that path exists and contains GTFS files.`
+      );
+    }
+  }
+};
+var createTables = (db) => {
+  for (const model56 of models_default) {
+    if (!model56.schema) {
+      return;
+    }
+    const columns = model56.schema.map((column) => {
+      let check = "";
+      if (column.min !== void 0 && column.max) {
+        check = `CHECK( ${column.name} >= ${column.min} AND ${column.name} <= ${column.max} )`;
+      } else if (column.min) {
+        check = `CHECK( ${column.name} >= ${column.min} )`;
+      } else if (column.max) {
+        check = `CHECK( ${column.name} <= ${column.max} )`;
+      }
+      const required = column.required ? "NOT NULL" : "";
+      const columnDefault = column.default ? "DEFAULT " + column.default : "";
+      const columnCollation = column.nocase ? "COLLATE NOCASE" : "";
+      return `${column.name} ${column.type} ${check} ${required} ${columnDefault} ${columnCollation}`;
+    });
+    const primaryColumns = model56.schema.filter((column) => column.primary);
+    if (primaryColumns.length > 0) {
+      columns.push(
+        `PRIMARY KEY (${primaryColumns.map((column) => column.name).join(", ")})`
+      );
+    }
+    db.prepare(`DROP TABLE IF EXISTS ${model56.filenameBase};`).run();
+    db.prepare(
+      `CREATE TABLE ${model56.filenameBase} (${columns.join(", ")});`
+    ).run();
+    for (const column of model56.schema.filter((column2) => column2.index)) {
+      db.prepare(
+        `CREATE INDEX idx_${model56.filenameBase}_${column.name} ON ${model56.filenameBase} (${column.name});`
+      ).run();
+    }
+  }
+};
+var formatLine = (line, model56, totalLineCount) => {
+  const lineNumber = totalLineCount + 1;
+  const formattedLine = {};
+  for (const columnSchema of model56.schema) {
+    const lineValue = line[columnSchema.name];
+    if (columnSchema.type === "integer") {
+      formattedLine[columnSchema.name] = Number.parseInt(lineValue, 10);
+    } else if (columnSchema.type === "real") {
+      formattedLine[columnSchema.name] = Number.parseFloat(lineValue);
+    } else {
+      formattedLine[columnSchema.name] = lineValue;
+    }
+    if (formattedLine[columnSchema.name] === "" || formattedLine[columnSchema.name] === void 0 || formattedLine[columnSchema.name] === null || Number.isNaN(formattedLine[columnSchema.name])) {
+      formattedLine[columnSchema.name] = null;
+    }
+    if (columnSchema.required === true && formattedLine[columnSchema.name] === null) {
+      throw new Error(
+        `Missing required value in ${model56.filenameBase}.${model56.filenameExtension} for ${columnSchema.name} on line ${lineNumber}.`
+      );
+    }
+    if (columnSchema.min !== void 0 && formattedLine[columnSchema.name] < columnSchema.min) {
+      throw new Error(
+        `Invalid value in ${model56.filenameBase}.${model56.filenameExtension} for ${columnSchema.name} on line ${lineNumber}: below minimum value of ${columnSchema.min}.`
+      );
+    }
+    if (columnSchema.max !== void 0 && formattedLine[columnSchema.name] > columnSchema.max) {
+      throw new Error(
+        `Invalid value in ${model56.filenameBase}.${model56.filenameExtension} for ${columnSchema.name} on line ${lineNumber}: above maximum value of ${columnSchema.max}.`
+      );
+    }
+  }
+  const timeColumnNames = [
+    "start_time",
+    "end_time",
+    "arrival_time",
+    "departure_time",
+    "prior_notice_last_time",
+    "prior_notice_start_time",
+    "start_pickup_drop_off_window"
+  ];
+  for (const timeColumnName of timeColumnNames) {
+    if (formattedLine[timeColumnName]) {
+      const timestampColumnName = timeColumnName.endsWith("time") ? `${timeColumnName}stamp` : `${timeColumnName}_timestamp`;
+      formattedLine[timestampColumnName] = calculateSecondsFromMidnight(
+        formattedLine[timeColumnName]
+      );
+      formattedLine[timeColumnName] = padLeadingZeros(
+        formattedLine[timeColumnName]
+      );
+    }
+  }
+  return formattedLine;
+};
+var importLines = (task, lines, model56, totalLineCount) => {
+  const db = openDb({
+    sqlitePath: task.sqlitePath,
+    agencies: []
+  });
+  if (lines.length === 0) {
+    return;
+  }
+  const linesToImportCount = lines.length;
+  const columns = model56.schema.filter((column) => column.name !== "id");
+  const placeholders = [];
+  const values = [];
+  while (lines.length > 0) {
+    const line = lines.pop();
+    if (line === void 0) {
+      continue;
+    }
+    placeholders.push(`(${columns.map(() => "?").join(", ")})`);
+    values.push(
+      ...columns.map((column) => {
+        if (task.prefix !== void 0 && column.prefix === true) {
+          return `${task.prefix}${line[column.name]}`;
+        }
+        return line[column.name];
+      })
+    );
+  }
+  try {
+    db.prepare(
+      `INSERT ${task.ignoreDuplicates ? "OR IGNORE" : ""} INTO ${model56.filenameBase} (${columns.map((column) => column.name).join(", ")}) VALUES ${placeholders.join(",")}`
+    ).run(...values);
+  } catch (error) {
+    if (error.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+      const primaryColumns = model56.schema.filter((column) => column.primary);
+      task.logWarning(
+        `Duplicate values for primary key (${primaryColumns.map((column) => column.name).join(", ")}) found in ${model56.filenameBase}.${model56.filenameExtension}. Set the \`ignoreDuplicates\` option to true in config.json to ignore this error`
+      );
+    }
+    task.logWarning(
+      `Check ${model56.filenameBase}.${model56.filenameExtension} for invalid data between lines ${totalLineCount - linesToImportCount} and ${totalLineCount}.`
+    );
+    throw error;
+  }
+  task.log(
+    `Importing - ${model56.filenameBase}.${model56.filenameExtension} - ${totalLineCount} lines imported\r`,
+    true
+  );
+};
+var importFiles = (task) => mapSeries(
+  models_default,
+  (model56) => new Promise((resolve, reject) => {
+    const lines = [];
+    let totalLineCount = 0;
+    const maxInsertVariables = 32e3;
+    if (task.exclude && task.exclude.includes(model56.filenameBase)) {
+      task.log(
+        `Skipping - ${model56.filenameBase}.${model56.filenameExtension}\r`
+      );
+      resolve();
+      return;
+    }
+    if (model56.extension === "gtfs-realtime") {
+      resolve();
+      return;
+    }
+    const filepath = path2.join(
+      task.downloadDir,
+      `${model56.filenameBase}.${model56.filenameExtension}`
+    );
+    if (!existsSync2(filepath)) {
+      if (!model56.nonstandard) {
+        task.log(
+          `Importing - ${model56.filenameBase}.${model56.filenameExtension} - No file found\r`
+        );
+      }
+      resolve();
+      return;
+    }
+    task.log(
+      `Importing - ${model56.filenameBase}.${model56.filenameExtension}\r`
+    );
+    if (model56.filenameExtension === "txt") {
+      const parser = parse({
+        columns: true,
+        relax_quotes: true,
+        trim: true,
+        skip_empty_lines: true,
+        ...task.csvOptions
+      });
+      parser.on("readable", () => {
+        let record;
+        while (record = parser.read()) {
+          try {
+            totalLineCount += 1;
+            lines.push(formatLine(record, model56, totalLineCount));
+            if (lines.length >= maxInsertVariables / model56.schema.length) {
+              importLines(task, lines, model56, totalLineCount);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        }
+      });
+      parser.on("end", () => {
+        try {
+          importLines(task, lines, model56, totalLineCount);
+        } catch (error) {
+          reject(error);
+        }
+        resolve();
+      });
+      parser.on("error", reject);
+      createReadStream(filepath).pipe(stripBomStream()).pipe(parser);
+    } else if (model56.filenameExtension === "geojson") {
+      readFile2(filepath, "utf8").then((data) => {
+        if (isValidJSON(data) === false) {
+          reject(
+            new Error(
+              `Invalid JSON in ${model56.filenameBase}.${model56.filenameExtension}`
+            )
+          );
+        }
+        const line = formatLine({ geojson: data }, model56, totalLineCount);
+        importLines(task, [line], model56, totalLineCount);
+        resolve();
+      }).catch(reject);
+    } else {
+      reject(
+        new Error(`Unsupported file type: ${model56.filenameExtension}`)
+      );
+    }
+  })
+);
+async function importGtfs(initialConfig) {
+  const config = setDefaultConfig(initialConfig);
+  validateConfigForImport(config);
+  const log2 = log(config);
+  const logError2 = logError(config);
+  const logWarning2 = logWarning(config);
+  try {
+    const db = openDb(config);
+    const agencyCount = config.agencies.length;
+    log2(
+      `Starting GTFS import for ${pluralize(
+        "file",
+        agencyCount,
+        true
+      )} using SQLite database at ${config.sqlitePath}`
+    );
+    createTables(db);
+    await mapSeries(
+      config.agencies,
+      async (agency) => {
+        const tempPath = temporaryDirectory();
+        const task = {
+          exclude: agency.exclude,
+          agency_url: agency.url,
+          headers: agency.headers,
+          realtime_headers: agency.realtimeHeaders,
+          realtime_urls: agency.realtimeUrls,
+          downloadDir: tempPath,
+          downloadTimeout: config.downloadTimeout,
+          gtfsRealtimeExpirationSeconds: config.gtfsRealtimeExpirationSeconds,
+          path: agency.path,
+          csvOptions: config.csvOptions || {},
+          ignoreDuplicates: config.ignoreDuplicates,
+          sqlitePath: config.sqlitePath,
+          prefix: agency.prefix,
+          currentTimestamp: Math.floor(Date.now() / 1e3),
+          log: log2,
+          logWarning: logWarning2,
+          logError: logError2
+        };
+        try {
+          if (task.agency_url) {
+            await downloadFiles(task);
+          }
+          await readFiles(task);
+          await importFiles(task);
+          await updateRealtimeData(task);
+          await rm2(tempPath, { recursive: true });
+        } catch (error) {
+          if (config.ignoreErrors) {
+            logError2(error.message);
+          } else {
+            throw error;
+          }
+        }
+      }
+    );
+    log2(
+      `Completed GTFS import for ${pluralize("agency", agencyCount, true)}
+`
+    );
+  } catch (error) {
+    if (error?.code === "SQLITE_CANTOPEN") {
+      logError2(
+        `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/lib/export.ts
+import { without, compact } from "lodash-es";
+import pluralize2 from "pluralize";
+import { stringify } from "csv-stringify";
+import sqlString3 from "sqlstring-sqlite";
+import mapSeries2 from "promise-map-series";
+import untildify4 from "untildify";
+
+// src/lib/advancedQuery.ts
+import sqlString4 from "sqlstring-sqlite";
+
+// src/lib/gtfs/agencies.ts
+import sqlString5 from "sqlstring-sqlite";
+
+// src/lib/gtfs/areas.ts
+import sqlString6 from "sqlstring-sqlite";
+
+// src/lib/gtfs/attributions.ts
+import sqlString7 from "sqlstring-sqlite";
+
+// src/lib/gtfs/booking-rules.ts
+import sqlString8 from "sqlstring-sqlite";
+
+// src/lib/gtfs/calendar-dates.ts
+import sqlString9 from "sqlstring-sqlite";
+
+// src/lib/gtfs/calendars.ts
+import sqlString10 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-attributes.ts
+import sqlString11 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-leg-rules.ts
+import sqlString12 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-media.ts
+import sqlString13 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-products.ts
+import sqlString14 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-rules.ts
+import sqlString15 from "sqlstring-sqlite";
+
+// src/lib/gtfs/fare-transfer-rules.ts
+import sqlString16 from "sqlstring-sqlite";
+
+// src/lib/gtfs/feed-info.ts
+import sqlString17 from "sqlstring-sqlite";
+
+// src/lib/gtfs/frequencies.ts
+import sqlString18 from "sqlstring-sqlite";
+
+// src/lib/gtfs/levels.ts
+import sqlString19 from "sqlstring-sqlite";
+
+// src/lib/gtfs/location-groups.ts
+import sqlString20 from "sqlstring-sqlite";
+
+// src/lib/gtfs/location-group-stops.ts
+import sqlString21 from "sqlstring-sqlite";
+
+// src/lib/gtfs/locations.ts
+import sqlString22 from "sqlstring-sqlite";
+
+// src/lib/gtfs/networks.ts
+import sqlString23 from "sqlstring-sqlite";
+
+// src/lib/gtfs/pathways.ts
+import sqlString24 from "sqlstring-sqlite";
+
+// src/lib/gtfs/route-networks.ts
+import sqlString25 from "sqlstring-sqlite";
+
+// src/lib/gtfs/routes.ts
+import { omit as omit3, pick } from "lodash-es";
+import sqlString26 from "sqlstring-sqlite";
+
+// src/lib/gtfs/shapes.ts
+import { omit as omit4, pick as pick2 } from "lodash-es";
+import sqlString28 from "sqlstring-sqlite";
+import { featureCollection as featureCollection2 } from "@turf/helpers";
+
+// src/lib/gtfs-plus/route-attributes.ts
+import sqlString27 from "sqlstring-sqlite";
+
+// src/lib/gtfs/stop-areas.ts
+import sqlString29 from "sqlstring-sqlite";
+
+// src/lib/gtfs/stops.ts
+import { omit as omit5, orderBy, pick as pick3 } from "lodash-es";
+import sqlString31 from "sqlstring-sqlite";
+
+// src/lib/gtfs-plus/stop-attributes.ts
+import sqlString30 from "sqlstring-sqlite";
+
+// src/lib/gtfs/stop-times.ts
+import sqlString32 from "sqlstring-sqlite";
+
+// src/lib/gtfs/timeframes.ts
+import sqlString33 from "sqlstring-sqlite";
+
+// src/lib/gtfs/transfers.ts
+import sqlString34 from "sqlstring-sqlite";
+
+// src/lib/gtfs/translations.ts
+import sqlString35 from "sqlstring-sqlite";
+
+// src/lib/gtfs/trips.ts
+import sqlString36 from "sqlstring-sqlite";
+
+// src/lib/gtfs-plus/calendar-attributes.ts
+import sqlString37 from "sqlstring-sqlite";
+
+// src/lib/gtfs-plus/directions.ts
+import sqlString38 from "sqlstring-sqlite";
+
+// src/lib/non-standard/timetables.ts
+import sqlString39 from "sqlstring-sqlite";
+
+// src/lib/non-standard/timetable-stop-order.ts
+import sqlString40 from "sqlstring-sqlite";
+
+// src/lib/non-standard/timetable-pages.ts
+import sqlString41 from "sqlstring-sqlite";
+
+// src/lib/non-standard/timetable-notes.ts
+import sqlString42 from "sqlstring-sqlite";
+
+// src/lib/non-standard/timetable-notes-references.ts
+import sqlString43 from "sqlstring-sqlite";
+
+// src/lib/non-standard/trips-dated-vehicle-journey.ts
+import sqlString44 from "sqlstring-sqlite";
+
+// src/lib/gtfs-ride/board-alights.ts
+import sqlString45 from "sqlstring-sqlite";
+
+// src/lib/gtfs-ride/ride-feed-infos.ts
+import sqlString46 from "sqlstring-sqlite";
+
+// src/lib/gtfs-ride/rider-trips.ts
+import sqlString47 from "sqlstring-sqlite";
+
+// src/lib/gtfs-ride/riderships.ts
+import sqlString48 from "sqlstring-sqlite";
+
+// src/lib/gtfs-ride/trip-capacities.ts
+import sqlString49 from "sqlstring-sqlite";
+
+// src/lib/gtfs-realtime/stop-time-updates.ts
+import sqlString50 from "sqlstring-sqlite";
+
+// src/lib/gtfs-realtime/trip-updates.ts
+import sqlString51 from "sqlstring-sqlite";
+
+// src/lib/gtfs-realtime/vehicle-positions.ts
+import sqlString52 from "sqlstring-sqlite";
+
+// src/lib/gtfs-realtime/service-alerts.ts
+import sqlString53 from "sqlstring-sqlite";
+
+// src/lib/ods/deadheads.ts
+import sqlString54 from "sqlstring-sqlite";
+
+// src/lib/ods/deadhead-times.ts
+import sqlString55 from "sqlstring-sqlite";
+
+// src/lib/ods/ops-locations.ts
+import sqlString56 from "sqlstring-sqlite";
+
+// src/lib/ods/run-events.ts
+import sqlString57 from "sqlstring-sqlite";
+
+// src/lib/ods/runs-pieces.ts
+import sqlString58 from "sqlstring-sqlite";
+
+// src/bin/gtfs-import.ts
+var pe = new PrettyError();
+var argv = yargs(hideBin(process.argv)).usage("Usage: $0 --configPath ./config.json").help().option("c", {
+  alias: "configPath",
+  describe: "Path to config file",
+  type: "string"
+}).option("gtfsPath", {
+  describe: "Path to gtfs (zipped or unzipped)",
+  type: "string"
+}).option("gtfsUrl", {
+  describe: "URL of gtfs file",
+  type: "string"
+}).option("sqlitePath", {
+  describe: "Path to SQLite database",
+  type: "string"
+}).parseSync();
+var handleError = (error = "Unknown Error") => {
+  process.stdout.write(`
+${formatError(error)}
+`);
+  console.error(pe.render(error));
+  process.exit(1);
+};
+var setupImport = async () => {
+  const config = await getConfig(argv);
+  await importGtfs(config);
+  const db = openDb(config);
+  if (db.name !== ":memory:") {
+    closeDb(db);
+  }
+  process.exit();
+};
+setupImport().catch(handleError);
+//# sourceMappingURL=gtfs-import.js.map