@lgriffin/esi.ts 9.4.0 → 9.6.0

package/dist/sde/memory.js

@@ -0,0 +1,1100 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sde/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  MemorySdeProvider: () => MemorySdeProvider,
+  SdeDatabaseError: () => SdeDatabaseError,
+  SdeError: () => SdeError,
+  SdeTestDataFactory: () => SdeTestDataFactory,
+  SdeValidationError: () => SdeValidationError,
+  SdeVersionMismatchError: () => SdeVersionMismatchError,
+  isSdeDatabaseError: () => isSdeDatabaseError,
+  isSdeError: () => isSdeError,
+  isSdeValidationError: () => isSdeValidationError,
+  isSdeVersionMismatch: () => isSdeVersionMismatch
+});
+module.exports = __toCommonJS(memory_exports);
+
+// src/sde/MemorySdeProvider.ts
+var MemorySdeProvider = class {
+  data = /* @__PURE__ */ new Map();
+  versionInfo;
+  constructor(data = {}) {
+    const register = (key, items, idFn) => {
+      this.data.set(
+        key,
+        new Map((items ?? []).map((item) => [idFn(item), item]))
+      );
+    };
+    register("eve_types", data.types, (t) => t.typeId);
+    register("eve_groups", data.groups, (g) => g.groupId);
+    register("eve_categories", data.categories, (c) => c.categoryId);
+    register("eve_regions", data.regions, (r) => r.regionId);
+    register(
+      "eve_constellations",
+      data.constellations,
+      (c) => c.constellationId
+    );
+    register("eve_solar_systems", data.solarSystems, (s) => s.systemId);
+    register("eve_stargates", data.stargates, (s) => s.stargateId);
+    register("eve_stars", data.stars, (s) => s.starId);
+    register("eve_planets", data.planets, (p) => p.planetId);
+    register("eve_moons", data.moons, (m) => m.moonId);
+    register("eve_asteroid_belts", data.asteroidBelts, (a) => a.asteroidBeltId);
+    register("eve_factions", data.factions, (f) => f.factionId);
+    register("eve_races", data.races, (r) => r.raceId);
+    register("eve_bloodlines", data.bloodlines, (b) => b.bloodlineId);
+    register("eve_ancestries", data.ancestries, (a) => a.ancestryId);
+    register(
+      "eve_npc_corporations",
+      data.npcCorporations,
+      (c) => c.corporationId
+    );
+    register("eve_npc_stations", data.npcStations, (s) => s.stationId);
+    register("eve_market_groups", data.marketGroups, (g) => g.marketGroupId);
+    register("eve_meta_groups", data.metaGroups, (g) => g.metaGroupId);
+    register("eve_icons", data.icons, (i) => i.iconId);
+    register("eve_graphics", data.graphics, (g) => g.graphicId);
+    register(
+      "eve_dogma_attributes",
+      data.dogmaAttributes,
+      (a) => a.attributeId
+    );
+    register("eve_dogma_effects", data.dogmaEffects, (e) => e.effectId);
+    register("eve_blueprints", data.blueprints, (b) => b.blueprintTypeId);
+    register(
+      "eve_planet_schematics",
+      data.planetSchematics,
+      (s) => s.planetSchematicId
+    );
+    register("eve_agent_types", data.agentTypes, (a) => a.agentTypeId);
+    register("eve_agents_in_space", data.agentsInSpace, (a) => a.characterId);
+    register("eve_certificates", data.certificates, (c) => c.certificateId);
+    register(
+      "eve_character_attributes",
+      data.characterAttributes,
+      (c) => c.attributeId
+    );
+    register("eve_clone_grades", data.cloneGrades, (c) => c.cloneGradeId);
+    register(
+      "eve_corporation_activities",
+      data.corporationActivities,
+      (c) => c.corporationActivityId
+    );
+    register(
+      "eve_dogma_attribute_categories",
+      data.dogmaAttributeCategories,
+      (d) => d.attributeCategoryId
+    );
+    register("eve_dogma_units", data.dogmaUnits, (d) => d.unitId);
+    register(
+      "eve_industry_activities",
+      data.industryActivities,
+      (i) => i.industryActivityId
+    );
+    register("eve_landmarks", data.landmarks, (l) => l.landmarkId);
+    register(
+      "eve_notification_types",
+      data.notificationTypes,
+      (n) => n.notificationTypeId
+    );
+    register("eve_npc_characters", data.npcCharacters, (n) => n.characterId);
+    register(
+      "eve_npc_corporation_divisions",
+      data.npcCorporationDivisions,
+      (n) => n.npcCorporationDivisionId
+    );
+    register("eve_schools", data.schools, (s) => s.schoolId);
+    register("eve_secondary_suns", data.secondarySuns, (s) => s.secondarySunId);
+    register("eve_skins", data.skins, (s) => s.skinId);
+    register("eve_skin_licenses", data.skinLicenses, (s) => s.licenseTypeId);
+    register(
+      "eve_station_operations",
+      data.stationOperations,
+      (s) => s.stationOperationId
+    );
+    register(
+      "eve_station_services",
+      data.stationServices,
+      (s) => s.stationServiceId
+    );
+    register("eve_type_dogma", data.typeDogma, (t) => t.typeId);
+    register("eve_type_materials", data.typeMaterials, (t) => t.typeId);
+    register("eve_type_bonuses", data.typeBonuses, (t) => t.typeId);
+    register("eve_missions", data.missions, (m) => m.missionId);
+    register("eve_dungeons", data.dungeons, (d) => d.dungeonId);
+    register("eve_epic_arcs", data.epicArcs, (e) => e.epicArcId);
+    this.versionInfo = {
+      version: data.version?.version ?? "1.0.0-test",
+      buildDate: data.version?.buildDate ?? "2024-01-01T00:00:00Z",
+      importedAt: data.version?.importedAt ?? "2024-01-01T00:00:00Z",
+      checksum: data.version?.checksum
+    };
+  }
+  getById(table, id) {
+    return this.data.get(table)?.get(id) ?? null;
+  }
+  getAllFrom(table) {
+    const map = this.data.get(table);
+    return map ? Array.from(map.values()) : [];
+  }
+  filterBy(table, field, value) {
+    return this.getAllFrom(table).filter(
+      (item) => item[field] === value
+    );
+  }
+  searchBy(table, field, query, limit = 25) {
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    for (const item of this.getAllFrom(table)) {
+      const val = item[field];
+      if (typeof val === "string" && val.toLowerCase().includes(lowerQuery)) {
+        results.push(item);
+        if (results.length >= limit) break;
+      }
+    }
+    return results;
+  }
+  // --- Types, Groups, Categories ---
+  getType(typeId) {
+    return this.getById("eve_types", typeId);
+  }
+  getTypesByGroup(groupId) {
+    return this.filterBy("eve_types", "groupId", groupId);
+  }
+  getGroup(groupId) {
+    return this.getById("eve_groups", groupId);
+  }
+  getGroupsByCategory(categoryId) {
+    return this.filterBy("eve_groups", "categoryId", categoryId);
+  }
+  getCategory(categoryId) {
+    return this.getById("eve_categories", categoryId);
+  }
+  getAllCategories() {
+    return this.getAllFrom("eve_categories");
+  }
+  // --- Regions, Constellations, Solar Systems, Stargates ---
+  getRegion(regionId) {
+    return this.getById("eve_regions", regionId);
+  }
+  getAllRegions() {
+    return this.getAllFrom("eve_regions");
+  }
+  getConstellation(constellationId) {
+    return this.getById("eve_constellations", constellationId);
+  }
+  getConstellationsByRegion(regionId) {
+    return this.filterBy("eve_constellations", "regionId", regionId);
+  }
+  getSolarSystem(systemId) {
+    return this.getById("eve_solar_systems", systemId);
+  }
+  getSolarSystemsByConstellation(constellationId) {
+    return this.filterBy(
+      "eve_solar_systems",
+      "constellationId",
+      constellationId
+    );
+  }
+  getStargate(stargateId) {
+    return this.getById("eve_stargates", stargateId);
+  }
+  getStargatesBySystem(systemId) {
+    return this.filterBy("eve_stargates", "solarSystemId", systemId);
+  }
+  // --- Search ---
+  searchTypesByName(query, limit = 25) {
+    return this.searchBy("eve_types", "name", query, limit);
+  }
+  searchSolarSystemsByName(query, limit = 25) {
+    return this.searchBy("eve_solar_systems", "name", query, limit);
+  }
+  // --- Universe ---
+  getStar(starId) {
+    return this.getById("eve_stars", starId);
+  }
+  getStarBySystem(systemId) {
+    return this.filterBy("eve_stars", "solarSystemId", systemId)[0] ?? null;
+  }
+  getPlanet(planetId) {
+    return this.getById("eve_planets", planetId);
+  }
+  getPlanetsBySystem(systemId) {
+    return this.filterBy("eve_planets", "solarSystemId", systemId);
+  }
+  getMoon(moonId) {
+    return this.getById("eve_moons", moonId);
+  }
+  getMoonsBySystem(systemId) {
+    return this.filterBy("eve_moons", "solarSystemId", systemId);
+  }
+  getAsteroidBelt(asteroidBeltId) {
+    return this.getById("eve_asteroid_belts", asteroidBeltId);
+  }
+  getAsteroidBeltsBySystem(systemId) {
+    return this.filterBy("eve_asteroid_belts", "solarSystemId", systemId);
+  }
+  // --- Character/Lore ---
+  getFaction(factionId) {
+    return this.getById("eve_factions", factionId);
+  }
+  getAllFactions() {
+    return this.getAllFrom("eve_factions");
+  }
+  getRace(raceId) {
+    return this.getById("eve_races", raceId);
+  }
+  getAllRaces() {
+    return this.getAllFrom("eve_races");
+  }
+  getBloodline(bloodlineId) {
+    return this.getById("eve_bloodlines", bloodlineId);
+  }
+  getBloodlinesByRace(raceId) {
+    return this.filterBy("eve_bloodlines", "raceId", raceId);
+  }
+  getAncestry(ancestryId) {
+    return this.getById("eve_ancestries", ancestryId);
+  }
+  getAncestriesByBloodline(bloodlineId) {
+    return this.filterBy("eve_ancestries", "bloodlineId", bloodlineId);
+  }
+  // --- NPC Infrastructure ---
+  getNpcCorporation(corporationId) {
+    return this.getById("eve_npc_corporations", corporationId);
+  }
+  getNpcCorporationsByFaction(factionId) {
+    return this.filterBy("eve_npc_corporations", "factionId", factionId);
+  }
+  getNpcStation(stationId) {
+    return this.getById("eve_npc_stations", stationId);
+  }
+  getNpcStationsBySystem(systemId) {
+    return this.filterBy("eve_npc_stations", "solarSystemId", systemId);
+  }
+  getNpcStationsByOwner(ownerId) {
+    return this.filterBy("eve_npc_stations", "ownerId", ownerId);
+  }
+  // --- Market ---
+  getMarketGroup(marketGroupId) {
+    return this.getById("eve_market_groups", marketGroupId);
+  }
+  getMarketGroupsByParent(parentGroupId) {
+    return this.filterBy("eve_market_groups", "parentGroupId", parentGroupId);
+  }
+  getRootMarketGroups() {
+    return this.getAllFrom("eve_market_groups").filter(
+      (g) => g.parentGroupId === null
+    );
+  }
+  getTypesByMarketGroup(marketGroupId) {
+    return this.filterBy("eve_types", "marketGroupId", marketGroupId);
+  }
+  searchMarketGroupsByName(query, limit = 25) {
+    return this.searchBy("eve_market_groups", "name", query, limit);
+  }
+  // --- Meta/UI ---
+  getMetaGroup(metaGroupId) {
+    return this.getById("eve_meta_groups", metaGroupId);
+  }
+  getAllMetaGroups() {
+    return this.getAllFrom("eve_meta_groups");
+  }
+  getIcon(iconId) {
+    return this.getById("eve_icons", iconId);
+  }
+  getGraphic(graphicId) {
+    return this.getById("eve_graphics", graphicId);
+  }
+  // --- Dogma ---
+  getDogmaAttribute(attributeId) {
+    return this.getById("eve_dogma_attributes", attributeId);
+  }
+  searchDogmaAttributesByName(query, limit = 25) {
+    return this.searchBy("eve_dogma_attributes", "name", query, limit);
+  }
+  getDogmaEffect(effectId) {
+    return this.getById("eve_dogma_effects", effectId);
+  }
+  searchDogmaEffectsByName(query, limit = 25) {
+    return this.searchBy("eve_dogma_effects", "name", query, limit);
+  }
+  getDogmaAttributeCategory(attributeCategoryId) {
+    return this.getById("eve_dogma_attribute_categories", attributeCategoryId);
+  }
+  getAllDogmaAttributeCategories() {
+    return this.getAllFrom("eve_dogma_attribute_categories");
+  }
+  getDogmaUnit(unitId) {
+    return this.getById("eve_dogma_units", unitId);
+  }
+  getAllDogmaUnits() {
+    return this.getAllFrom("eve_dogma_units");
+  }
+  // --- Industry ---
+  getBlueprint(blueprintTypeId) {
+    return this.getById("eve_blueprints", blueprintTypeId);
+  }
+  getPlanetSchematic(planetSchematicId) {
+    return this.getById("eve_planet_schematics", planetSchematicId);
+  }
+  getAllPlanetSchematics() {
+    return this.getAllFrom("eve_planet_schematics");
+  }
+  getIndustryActivity(industryActivityId) {
+    return this.getById("eve_industry_activities", industryActivityId);
+  }
+  getAllIndustryActivities() {
+    return this.getAllFrom("eve_industry_activities");
+  }
+  // --- Agent System ---
+  getAgentType(agentTypeId) {
+    return this.getById("eve_agent_types", agentTypeId);
+  }
+  getAllAgentTypes() {
+    return this.getAllFrom("eve_agent_types");
+  }
+  getAgentInSpace(characterId) {
+    return this.getById("eve_agents_in_space", characterId);
+  }
+  getAgentsInSpaceBySystem(systemId) {
+    return this.filterBy("eve_agents_in_space", "solarSystemId", systemId);
+  }
+  // --- Certificates ---
+  getCertificate(certificateId) {
+    return this.getById("eve_certificates", certificateId);
+  }
+  getAllCertificates() {
+    return this.getAllFrom("eve_certificates");
+  }
+  // --- Character Attributes ---
+  getCharacterAttribute(attributeId) {
+    return this.getById("eve_character_attributes", attributeId);
+  }
+  getAllCharacterAttributes() {
+    return this.getAllFrom("eve_character_attributes");
+  }
+  // --- NPC Characters ---
+  getNpcCharacter(characterId) {
+    return this.getById("eve_npc_characters", characterId);
+  }
+  getNpcCharactersByCorporation(corporationId) {
+    return this.filterBy("eve_npc_characters", "corporationId", corporationId);
+  }
+  searchNpcCharactersByName(query, limit = 25) {
+    return this.searchBy("eve_npc_characters", "name", query, limit);
+  }
+  // --- Clone Grades ---
+  getCloneGrade(cloneGradeId) {
+    return this.getById("eve_clone_grades", cloneGradeId);
+  }
+  getAllCloneGrades() {
+    return this.getAllFrom("eve_clone_grades");
+  }
+  // --- Corporation Reference ---
+  getCorporationActivity(corporationActivityId) {
+    return this.getById("eve_corporation_activities", corporationActivityId);
+  }
+  getAllCorporationActivities() {
+    return this.getAllFrom("eve_corporation_activities");
+  }
+  getNpcCorporationDivision(npcCorporationDivisionId) {
+    return this.getById(
+      "eve_npc_corporation_divisions",
+      npcCorporationDivisionId
+    );
+  }
+  getAllNpcCorporationDivisions() {
+    return this.getAllFrom("eve_npc_corporation_divisions");
+  }
+  // --- Landmarks ---
+  getLandmark(landmarkId) {
+    return this.getById("eve_landmarks", landmarkId);
+  }
+  getAllLandmarks() {
+    return this.getAllFrom("eve_landmarks");
+  }
+  // --- Notifications ---
+  getNotificationType(notificationTypeId) {
+    return this.getById("eve_notification_types", notificationTypeId);
+  }
+  // --- Schools ---
+  getSchool(schoolId) {
+    return this.getById("eve_schools", schoolId);
+  }
+  getAllSchools() {
+    return this.getAllFrom("eve_schools");
+  }
+  // --- Secondary Suns ---
+  getSecondarySun(secondarySunId) {
+    return this.getById("eve_secondary_suns", secondarySunId);
+  }
+  getSecondarySunsBySystem(systemId) {
+    return this.filterBy("eve_secondary_suns", "solarSystemId", systemId);
+  }
+  // --- Skins ---
+  getSkin(skinId) {
+    return this.getById("eve_skins", skinId);
+  }
+  getSkinLicense(licenseTypeId) {
+    return this.getById("eve_skin_licenses", licenseTypeId);
+  }
+  getSkinLicensesBySkin(skinId) {
+    return this.filterBy("eve_skin_licenses", "skinId", skinId);
+  }
+  // --- Station Operations & Services ---
+  getStationOperation(stationOperationId) {
+    return this.getById("eve_station_operations", stationOperationId);
+  }
+  getAllStationOperations() {
+    return this.getAllFrom("eve_station_operations");
+  }
+  getStationService(stationServiceId) {
+    return this.getById("eve_station_services", stationServiceId);
+  }
+  getAllStationServices() {
+    return this.getAllFrom("eve_station_services");
+  }
+  // --- Type Extensions ---
+  getTypeDogma(typeId) {
+    return this.getById("eve_type_dogma", typeId);
+  }
+  getTypeMaterial(typeId) {
+    return this.getById("eve_type_materials", typeId);
+  }
+  getTypeBonus(typeId) {
+    return this.getById("eve_type_bonuses", typeId);
+  }
+  // --- Missions & Content ---
+  getMission(missionId) {
+    return this.getById("eve_missions", missionId);
+  }
+  getDungeon(dungeonId) {
+    return this.getById("eve_dungeons", dungeonId);
+  }
+  getEpicArc(epicArcId) {
+    return this.getById("eve_epic_arcs", epicArcId);
+  }
+  getAllEpicArcs() {
+    return this.getAllFrom("eve_epic_arcs");
+  }
+  // --- Generic accessor ---
+  getEntity(tableName, id) {
+    return this.getById(tableName, id);
+  }
+  getAllEntities(tableName) {
+    return this.getAllFrom(tableName);
+  }
+  // --- Version & Lifecycle ---
+  getVersion() {
+    return { ...this.versionInfo };
+  }
+  close() {
+    this.data.clear();
+  }
+};
+
+// src/sde/errors.ts
+var SdeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SdeError";
+  }
+};
+var SdeDatabaseError = class extends SdeError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "SdeDatabaseError";
+    this.cause = cause;
+  }
+};
+var SdeValidationError = class extends SdeError {
+  validationError;
+  entityType;
+  entityId;
+  constructor(entityType, validationError, entityId) {
+    const idSuffix = entityId !== void 0 ? ` (id: ${entityId})` : "";
+    super(`SDE validation failed for ${entityType}${idSuffix}`);
+    this.name = "SdeValidationError";
+    this.validationError = validationError;
+    this.entityType = entityType;
+    this.entityId = entityId;
+  }
+};
+var SdeVersionMismatchError = class extends SdeError {
+  expected;
+  actual;
+  constructor(expected, actual) {
+    super(`SDE version mismatch: expected ${expected}, got ${actual}`);
+    this.name = "SdeVersionMismatchError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+function isSdeError(error) {
+  return error instanceof SdeError;
+}
+function isSdeDatabaseError(error) {
+  return error instanceof SdeDatabaseError;
+}
+function isSdeValidationError(error) {
+  return error instanceof SdeValidationError;
+}
+function isSdeVersionMismatch(error) {
+  return error instanceof SdeVersionMismatchError;
+}
+
+// src/sde/SdeTestDataFactory.ts
+var SdeTestDataFactory = class {
+  static createEveType(overrides = {}) {
+    return {
+      typeId: 34,
+      groupId: 18,
+      mass: 1,
+      name: "Tritanium",
+      portionSize: 1,
+      published: true,
+      packagedVolume: null,
+      volume: 0.01,
+      radius: null,
+      description: "The most common mineral in the known universe.",
+      graphicId: 20,
+      soundId: null,
+      iconId: null,
+      raceId: null,
+      basePrice: 4,
+      marketGroupId: 1857,
+      capacity: null,
+      isRepackable: null,
+      ...overrides
+    };
+  }
+  static createEveGroup(overrides = {}) {
+    return {
+      groupId: 18,
+      anchorable: false,
+      anchored: false,
+      categoryId: 4,
+      fittableNonSingleton: false,
+      name: "Mineral",
+      published: true,
+      useBasePrice: true,
+      iconId: null,
+      ...overrides
+    };
+  }
+  static createEveCategory(overrides = {}) {
+    return {
+      categoryId: 4,
+      name: "Material",
+      published: true,
+      iconId: null,
+      ...overrides
+    };
+  }
+  static createRegion(overrides = {}) {
+    return {
+      regionId: 10000002,
+      constellationIDs: [20000020],
+      description: "The Forge is the industrial heart of the Caldari State.",
+      factionId: 500001,
+      name: "The Forge",
+      nebulaId: 10,
+      position: { x: -96e15, y: 6e16, z: -11e16 },
+      wormholeClassId: 0,
+      ...overrides
+    };
+  }
+  static createConstellation(overrides = {}) {
+    return {
+      constellationId: 20000020,
+      factionId: 500001,
+      name: "Kimotoro",
+      position: { x: -97e15, y: 61e15, z: -115e15 },
+      regionId: 10000002,
+      solarSystemIDs: [30000142, 30000144],
+      wormholeClassId: 0,
+      ...overrides
+    };
+  }
+  static createSolarSystem(overrides = {}) {
+    return {
+      systemId: 30000142,
+      border: false,
+      constellationId: 20000020,
+      hub: true,
+      international: false,
+      luminosity: 0.02142,
+      name: "Jita",
+      planetIDs: [40009077],
+      position: { x: -129e15, y: 607e14, z: -112e15 },
+      position2D: { x: -129e15, y: -112e15 },
+      radius: 467e10,
+      regionId: 10000002,
+      regional: false,
+      securityClass: "B",
+      securityStatus: 0.9459991455078125,
+      starId: 40009082,
+      stargateIDs: [50001248],
+      corridor: null,
+      fringe: null,
+      wormholeClassId: null,
+      visualEffect: null,
+      ...overrides
+    };
+  }
+  static createStargate(overrides = {}) {
+    return {
+      stargateId: 50001248,
+      destination: { solarSystemId: 30000144, stargateId: 50001249 },
+      position: { x: 15e11, y: 32e10, z: -87e10 },
+      solarSystemId: 30000142,
+      typeId: 16,
+      ...overrides
+    };
+  }
+  static createStar(overrides = {}) {
+    return {
+      starId: 40009082,
+      radius: 3466e5,
+      solarSystemId: 30000142,
+      statistics: {
+        age: 76e9,
+        life: 1e11,
+        luminosity: 0.02142,
+        locked: false,
+        spectralClass: "K7 V",
+        temperature: 4e3
+      },
+      typeId: 3796,
+      ...overrides
+    };
+  }
+  static createPlanet(overrides = {}) {
+    return {
+      planetId: 40009077,
+      asteroidBeltIDs: [40009079],
+      attributes: {},
+      celestialIndex: 1,
+      moonIDs: [40009078],
+      orbitId: 40009082,
+      position: { x: 12e12, y: 1e11, z: -35e11 },
+      radius: 233e4,
+      solarSystemId: 30000142,
+      statistics: {},
+      typeId: 2015,
+      npcStationIDs: null,
+      ...overrides
+    };
+  }
+  static createMoon(overrides = {}) {
+    return {
+      moonId: 40009078,
+      attributes: {},
+      celestialIndex: 1,
+      orbitId: 40009077,
+      orbitIndex: 1,
+      position: { x: 121e11, y: 101e9, z: -351e10 },
+      radius: 24e4,
+      solarSystemId: 30000142,
+      statistics: {},
+      typeId: 14,
+      npcStationIDs: null,
+      ...overrides
+    };
+  }
+  static createAsteroidBelt(overrides = {}) {
+    return {
+      asteroidBeltId: 40009079,
+      celestialIndex: 1,
+      orbitId: 40009077,
+      orbitIndex: 1,
+      position: { x: 119e11, y: 99e9, z: -349e10 },
+      radius: 5e4,
+      solarSystemId: 30000142,
+      statistics: {},
+      typeId: 15,
+      ...overrides
+    };
+  }
+  static createFaction(overrides = {}) {
+    return {
+      factionId: 500001,
+      corporationId: 1000035,
+      description: "The Caldari State is a corporate dictatorship.",
+      flatLogo: "res:/ui/texture/corps/caldari.png",
+      flatLogoWithName: "res:/ui/texture/corps/caldari_name.png",
+      iconId: 1439,
+      memberRaces: [1],
+      militiaCorporationId: 1000180,
+      name: "Caldari State",
+      shortDescription: "Caldari",
+      sizeFactor: 5,
+      solarSystemId: 30000142,
+      uniqueName: true,
+      ...overrides
+    };
+  }
+  static createRace(overrides = {}) {
+    return {
+      raceId: 1,
+      description: "The Caldari State is a corporate dictatorship.",
+      iconId: 1439,
+      name: "Caldari",
+      shipTypeId: 601,
+      skills: {},
+      ...overrides
+    };
+  }
+  static createBloodline(overrides = {}) {
+    return {
+      bloodlineId: 1,
+      charisma: 3,
+      corporationId: 1000006,
+      description: "The Deteis are regarded as the face of the Caldari State.",
+      iconId: 1383,
+      intelligence: 7,
+      memory: 7,
+      name: "Deteis",
+      perception: 5,
+      raceId: 1,
+      willpower: 5,
+      ...overrides
+    };
+  }
+  static createAncestry(overrides = {}) {
+    return {
+      ancestryId: 1,
+      bloodlineId: 1,
+      charisma: 0,
+      description: "Born and raised in a capsule.",
+      iconId: 1664,
+      intelligence: 0,
+      memory: 0,
+      name: "Tube Child",
+      perception: 0,
+      shortDescription: "Raised in a capsule.",
+      willpower: 2,
+      ...overrides
+    };
+  }
+  static createNpcCorporation(overrides = {}) {
+    return {
+      corporationId: 1000035,
+      ceoId: 3004451,
+      deleted: false,
+      description: "The Caldari Navy is the armed forces of the Caldari State.",
+      extent: "G",
+      hasPlayerPersonnelManager: false,
+      initialPrice: 0,
+      memberLimit: 0,
+      minSecurity: 0,
+      minimumJoinStanding: 0,
+      name: "Caldari Navy",
+      sendCharTerminationMessage: true,
+      shares: 1e5,
+      size: "H",
+      stationId: 60003760,
+      taxRate: 0,
+      tickerName: "CN",
+      uniqueName: true,
+      allowedMemberRaces: null,
+      corporationTrades: null,
+      divisions: null,
+      enemyId: null,
+      factionId: 500001,
+      friendId: null,
+      iconId: 1439,
+      investors: null,
+      lpOfferTables: null,
+      mainActivityId: null,
+      raceId: 1,
+      sizeFactor: null,
+      solarSystemId: 30000142,
+      secondaryActivityId: null,
+      ...overrides
+    };
+  }
+  static createNpcStation(overrides = {}) {
+    return {
+      stationId: 60003760,
+      celestialIndex: 4,
+      operationId: 1,
+      orbitId: 40009081,
+      orbitIndex: 4,
+      ownerId: 1000035,
+      position: { x: 158e12, y: 963e10, z: 106e12 },
+      reprocessingEfficiency: 0.5,
+      reprocessingHangarFlag: 4,
+      reprocessingStationsTake: 0.05,
+      solarSystemId: 30000142,
+      typeId: 1529,
+      useOperationName: true,
+      ...overrides
+    };
+  }
+  static createMarketGroup(overrides = {}) {
+    return {
+      marketGroupId: 1857,
+      description: "Refined minerals used in manufacturing.",
+      hasTypes: true,
+      iconId: 22,
+      name: "Minerals",
+      parentGroupId: 1031,
+      ...overrides
+    };
+  }
+  static createMetaGroup(overrides = {}) {
+    return {
+      metaGroupId: 1,
+      color: { r: 255, g: 255, b: 255, a: 255 },
+      name: "Tech I",
+      iconId: null,
+      iconSuffix: null,
+      description: null,
+      ...overrides
+    };
+  }
+  static createIcon(overrides = {}) {
+    return {
+      iconId: 22,
+      iconFile: "res:/UI/Texture/Icons/22_32_2.png",
+      ...overrides
+    };
+  }
+  static createGraphic(overrides = {}) {
+    return {
+      graphicId: 20,
+      graphicFile: "res:/dx9/model/worldobject/asteroid/oreveld001.red",
+      iconFolder: null,
+      sofFactionName: null,
+      sofHullName: null,
+      sofRaceName: null,
+      ...overrides
+    };
+  }
+  static createDogmaAttribute(overrides = {}) {
+    return {
+      attributeId: 9,
+      attributeCategoryId: 1,
+      dataType: 2,
+      defaultValue: 0,
+      description: "Hit points for a ship.",
+      displayWhenZero: false,
+      highIsGood: true,
+      name: "hp",
+      published: true,
+      stackable: false,
+      displayName: null,
+      iconId: null,
+      tooltipDescription: null,
+      tooltipTitle: null,
+      unitId: 1,
+      chargeRechargeTimeId: null,
+      maxAttributeId: null,
+      minAttributeId: null,
+      ...overrides
+    };
+  }
+  static createDogmaEffect(overrides = {}) {
+    return {
+      effectId: 11,
+      disallowAutoRepeat: false,
+      dischargeAttributeId: 0,
+      durationAttributeId: 0,
+      effectCategoryId: 0,
+      electronicChance: false,
+      guid: "effects.LowSlotModifier",
+      isAssistance: false,
+      isOffensive: false,
+      isWarpSafe: true,
+      name: "lowSlotModifier",
+      propulsionChance: false,
+      published: true,
+      rangeChance: false,
+      distribution: null,
+      falloffAttributeId: null,
+      rangeAttributeId: null,
+      trackingSpeedAttributeId: null,
+      description: null,
+      displayName: null,
+      iconId: null,
+      modifierInfo: null,
+      ...overrides
+    };
+  }
+  static createBlueprint(overrides = {}) {
+    return {
+      activities: {
+        manufacturing: {
+          time: 6e3,
+          materials: [
+            { typeId: 34, quantity: 100 },
+            { typeId: 35, quantity: 50 }
+          ],
+          products: [{ typeId: 587, quantity: 1 }]
+        }
+      },
+      blueprintTypeId: 787,
+      maxProductionLimit: 10,
+      ...overrides
+    };
+  }
+  static createPlanetSchematic(overrides = {}) {
+    return {
+      planetSchematicId: 65,
+      cycleTime: 1800,
+      name: "Bacteria",
+      pins: [],
+      types: [],
+      ...overrides
+    };
+  }
+  static createVersionInfo(overrides = {}) {
+    return {
+      version: "2024-01-15.1",
+      buildDate: "2024-01-15T00:00:00Z",
+      importedAt: "2024-01-16T12:00:00Z",
+      checksum: "abc123def456",
+      ...overrides
+    };
+  }
+  static createHierarchicalTestData() {
+    const category = this.createEveCategory();
+    const group = this.createEveGroup({ categoryId: category.categoryId });
+    const type1 = this.createEveType({
+      typeId: 34,
+      name: "Tritanium",
+      groupId: group.groupId
+    });
+    const type2 = this.createEveType({
+      typeId: 35,
+      name: "Pyerite",
+      groupId: group.groupId
+    });
+    const type3 = this.createEveType({
+      typeId: 36,
+      name: "Mexallon",
+      groupId: group.groupId
+    });
+    const region = this.createRegion();
+    const constellation = this.createConstellation({
+      regionId: region.regionId
+    });
+    const system1 = this.createSolarSystem({
+      systemId: 30000142,
+      name: "Jita",
+      constellationId: constellation.constellationId,
+      regionId: region.regionId
+    });
+    const system2 = this.createSolarSystem({
+      systemId: 30000144,
+      name: "Perimeter",
+      constellationId: constellation.constellationId,
+      regionId: region.regionId,
+      securityStatus: 0.9
+    });
+    const stargate = this.createStargate({
+      solarSystemId: system1.systemId,
+      destination: { solarSystemId: system2.systemId, stargateId: 50001249 }
+    });
+    const star = this.createStar({ solarSystemId: system1.systemId });
+    const planet = this.createPlanet({ solarSystemId: system1.systemId });
+    const moon = this.createMoon({ solarSystemId: system1.systemId });
+    const asteroidBelt = this.createAsteroidBelt({
+      solarSystemId: system1.systemId
+    });
+    const race = this.createRace();
+    const faction = this.createFaction({ memberRaces: [race.raceId] });
+    const bloodline = this.createBloodline({ raceId: race.raceId });
+    const ancestry = this.createAncestry({
+      bloodlineId: bloodline.bloodlineId
+    });
+    const npcCorp = this.createNpcCorporation({
+      factionId: faction.factionId,
+      raceId: race.raceId
+    });
+    const npcStation = this.createNpcStation({
+      solarSystemId: system1.systemId,
+      ownerId: npcCorp.corporationId
+    });
+    const rootMarketGroup = this.createMarketGroup({
+      marketGroupId: 1031,
+      name: "Manufacture & Research",
+      parentGroupId: null,
+      hasTypes: false
+    });
+    const marketGroup = this.createMarketGroup({
+      parentGroupId: rootMarketGroup.marketGroupId
+    });
+    const metaGroup = this.createMetaGroup();
+    const icon = this.createIcon();
+    const graphic = this.createGraphic();
+    const dogmaAttribute = this.createDogmaAttribute();
+    const dogmaEffect = this.createDogmaEffect();
+    const blueprint = this.createBlueprint();
+    const planetSchematic = this.createPlanetSchematic();
+    return {
+      categories: [category],
+      groups: [group],
+      types: [type1, type2, type3],
+      regions: [region],
+      constellations: [constellation],
+      solarSystems: [system1, system2],
+      stargates: [stargate],
+      stars: [star],
+      planets: [planet],
+      moons: [moon],
+      asteroidBelts: [asteroidBelt],
+      factions: [faction],
+      races: [race],
+      bloodlines: [bloodline],
+      ancestries: [ancestry],
+      npcCorporations: [npcCorp],
+      npcStations: [npcStation],
+      marketGroups: [rootMarketGroup, marketGroup],
+      metaGroups: [metaGroup],
+      icons: [icon],
+      graphics: [graphic],
+      dogmaAttributes: [dogmaAttribute],
+      dogmaEffects: [dogmaEffect],
+      blueprints: [blueprint],
+      planetSchematics: [planetSchematic],
+      version: this.createVersionInfo()
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemorySdeProvider,
+  SdeDatabaseError,
+  SdeError,
+  SdeTestDataFactory,
+  SdeValidationError,
+  SdeVersionMismatchError,
+  isSdeDatabaseError,
+  isSdeError,
+  isSdeValidationError,
+  isSdeVersionMismatch
+});
+//# sourceMappingURL=memory.js.map