@alpaca-software/40kdc-data 0.1.0

package/dist/data/collection.d.ts

@@ -0,0 +1,64 @@
+/** How a {@link Collection} reads keys and builds views from raw records. */
+export interface CollectionConfig<T, V> {
+    items: T[];
+    /** Primary id of a record (e.g. `u => u.id`, `a => a.ability_id`). */
+    idOf: (item: T) => string;
+    /**
+     * Uniqueness key used for deduplication. Defaults to {@link idOf}. Set to a
+     * composite (e.g. `(faction_id, id)`) for records that share an id across
+     * factions, so distinct copies are preserved rather than collapsed.
+     */
+    dedupeKeyOf?: (item: T) => string;
+    /** Display name, if the record has one — drives {@link Collection.find}. */
+    nameOf?: (item: T) => string | undefined;
+    /** Owning faction id, if applicable — drives {@link Collection.byFaction}. */
+    factionOf?: (item: T) => string | null | undefined;
+    /** Wrap a raw record in its linked view. */
+    wrap: (item: T) => V;
+}
+/**
+ * A collection of one entity type, exposing id/name/faction lookups.
+ *
+ * Iterable: `for (const unit of units) { … }`.
+ *
+ * @typeParam T - the raw (generated) record type
+ * @typeParam V - the linked view type returned to callers
+ */
+export declare class Collection<T, V> implements Iterable<V> {
+    private readonly items;
+    private readonly byId;
+    private readonly byNorm;
+    private readonly byFactionId;
+    private readonly nameOf?;
+    private readonly wrapFn;
+    constructor(cfg: CollectionConfig<T, V>);
+    /** Every record, deduplicated by id, in first-seen order. */
+    get all(): V[];
+    /** Number of distinct records. */
+    get size(): number;
+    /** Look up by exact id. */
+    get(id: string): V | undefined;
+    /** Whether a record with this exact id exists. */
+    has(id: string): boolean;
+    /**
+     * Find one record by id or name. Name matching is diacritic- and
+     * punctuation-insensitive (see {@link normalizeName}), trying, in order:
+     * exact id → exact normalized name → normalized-name substring. Returns the
+     * first match; names can repeat across factions, so use {@link findAll} or
+     * {@link byFaction} when a query may be ambiguous.
+     *
+     * @example
+     * units.find("Kharn"); // resolves "Khârn the Betrayer"
+     */
+    find(query: string): V | undefined;
+    /**
+     * All records matching a query, by the same rules as {@link find}. An exact id
+     * match returns just that record; otherwise every normalized-name-exact match
+     * is returned, falling back to every normalized-name-substring match. Useful
+     * to surface (rather than silently collapse) names shared across factions.
+     */
+    findAll(query: string): V[];
+    /** All records belonging to a faction id (empty if the type has no faction). */
+    byFaction(factionId: string): V[];
+    [Symbol.iterator](): Iterator<V>;
+}

package/dist/data/collection.js

@@ -0,0 +1,118 @@
+/**
+ * A queryable, iterable view over one entity collection.
+ *
+ * Indexes (by id, by normalized name, by faction) are built once at construction.
+ * Records are deduplicated by {@link CollectionConfig.dedupeKeyOf} (default: id,
+ * first occurrence wins). Some records are intentionally shared: the same unit
+ * id (e.g. `ministorum-priest`) appears under several factions, so units dedupe
+ * on `(faction_id, id)` to keep each faction's copy; identical core abilities
+ * (e.g. `leader`) copied into many faction files dedupe away on `ability_id`.
+ *
+ * `get(id)`/`find` return the first match when an id is shared across factions;
+ * use {@link Collection.byFaction} or {@link Collection.findAll} to disambiguate.
+ *
+ * @packageDocumentation
+ */
+import { normalizeName } from "./normalize.js";
+/**
+ * A collection of one entity type, exposing id/name/faction lookups.
+ *
+ * Iterable: `for (const unit of units) { … }`.
+ *
+ * @typeParam T - the raw (generated) record type
+ * @typeParam V - the linked view type returned to callers
+ */
+export class Collection {
+    items = [];
+    byId = new Map();
+    byNorm = new Map();
+    byFactionId = new Map();
+    nameOf;
+    wrapFn;
+    constructor(cfg) {
+        this.nameOf = cfg.nameOf;
+        this.wrapFn = cfg.wrap;
+        const dedupeKeyOf = cfg.dedupeKeyOf ?? cfg.idOf;
+        const seen = new Set();
+        for (const item of cfg.items) {
+            const dedupeKey = dedupeKeyOf(item);
+            if (seen.has(dedupeKey))
+                continue; // first-wins dedup
+            seen.add(dedupeKey);
+            this.items.push(item);
+            const id = cfg.idOf(item);
+            if (!this.byId.has(id))
+                this.byId.set(id, item); // first-wins for shared ids
+            const name = cfg.nameOf?.(item);
+            if (name)
+                push(this.byNorm, normalizeName(name), item);
+            const faction = cfg.factionOf?.(item);
+            if (faction)
+                push(this.byFactionId, faction, item);
+        }
+    }
+    /** Every record, deduplicated by id, in first-seen order. */
+    get all() {
+        return this.items.map((item) => this.wrapFn(item));
+    }
+    /** Number of distinct records. */
+    get size() {
+        return this.items.length;
+    }
+    /** Look up by exact id. */
+    get(id) {
+        const item = this.byId.get(id);
+        return item ? this.wrapFn(item) : undefined;
+    }
+    /** Whether a record with this exact id exists. */
+    has(id) {
+        return this.byId.has(id);
+    }
+    /**
+     * Find one record by id or name. Name matching is diacritic- and
+     * punctuation-insensitive (see {@link normalizeName}), trying, in order:
+     * exact id → exact normalized name → normalized-name substring. Returns the
+     * first match; names can repeat across factions, so use {@link findAll} or
+     * {@link byFaction} when a query may be ambiguous.
+     *
+     * @example
+     * units.find("Kharn"); // resolves "Khârn the Betrayer"
+     */
+    find(query) {
+        return this.findAll(query)[0];
+    }
+    /**
+     * All records matching a query, by the same rules as {@link find}. An exact id
+     * match returns just that record; otherwise every normalized-name-exact match
+     * is returned, falling back to every normalized-name-substring match. Useful
+     * to surface (rather than silently collapse) names shared across factions.
+     */
+    findAll(query) {
+        const byId = this.byId.get(query);
+        if (byId)
+            return [this.wrapFn(byId)];
+        const key = normalizeName(query);
+        const exact = this.byNorm.get(key);
+        if (exact && exact.length > 0)
+            return exact.map((i) => this.wrapFn(i));
+        if (!this.nameOf || key === "")
+            return [];
+        return this.items
+            .filter((item) => normalizeName(this.nameOf(item) ?? "").includes(key))
+            .map((item) => this.wrapFn(item));
+    }
+    /** All records belonging to a faction id (empty if the type has no faction). */
+    byFaction(factionId) {
+        return (this.byFactionId.get(factionId) ?? []).map((i) => this.wrapFn(i));
+    }
+    [Symbol.iterator]() {
+        return this.items.map((item) => this.wrapFn(item))[Symbol.iterator]();
+    }
+}
+function push(map, key, value) {
+    const existing = map.get(key);
+    if (existing)
+        existing.push(value);
+    else
+        map.set(key, [value]);
+}

package/dist/data/dataset.d.ts

@@ -0,0 +1,50 @@
+/**
+ * {@link Dataset} ties the embedded records together: it owns every
+ * {@link Collection}, builds the cross-entity indexes once, and is the `this`
+ * the linked views resolve against.
+ *
+ * @packageDocumentation
+ */
+import type { DeploymentPattern, Detachment, Enhancement, ForceDisposition, GameVersion, InteractionFlag, LeaderAttachment, Mission, MissionMatchup, Phase, ResourcePool, SecondaryCard, Stratagem, TimingFlag, Unit, UnitComposition, WargearOption } from "../generated.js";
+import { Collection } from "./collection.js";
+import { AbilityView, FactionView, UnitView, WeaponView } from "./entities.js";
+import { type RawData } from "./types.js";
+/** The whole dataset, with linked accessors over every entity collection. */
+export declare class Dataset {
+    readonly units: Collection<Unit, UnitView>;
+    readonly weapons: Collection<RawData["weapons"][number], WeaponView>;
+    readonly factions: Collection<RawData["factions"][number], FactionView>;
+    readonly abilities: Collection<RawData["abilities"][number], AbilityView>;
+    readonly detachments: Collection<Detachment, Detachment>;
+    readonly enhancements: Collection<Enhancement, Enhancement>;
+    readonly stratagems: Collection<Stratagem, Stratagem>;
+    readonly wargearOptions: Collection<WargearOption, WargearOption>;
+    readonly missions: Collection<Mission, Mission>;
+    readonly missionMatchups: Collection<MissionMatchup, MissionMatchup>;
+    readonly secondaryCards: Collection<SecondaryCard, SecondaryCard>;
+    readonly deploymentPatterns: Collection<DeploymentPattern, DeploymentPattern>;
+    readonly forceDispositions: Collection<ForceDisposition, ForceDisposition>;
+    readonly resourcePools: Collection<ResourcePool, ResourcePool>;
+    readonly leaderAttachments: readonly LeaderAttachment[];
+    readonly unitCompositions: readonly UnitComposition[];
+    readonly gameVersions: readonly GameVersion[];
+    readonly timingFlags: readonly TimingFlag[];
+    readonly interactionFlags: readonly InteractionFlag[];
+    readonly phaseMappings: readonly RawData["phaseMappings"][number][];
+    /** `source_type:source_id` → unioned phases. */
+    private readonly phaseIndex;
+    /** ability id → units that list it. */
+    private readonly unitsByAbility;
+    /** weapon id → units that list it. */
+    private readonly unitsByWeapon;
+    constructor(raw?: RawData);
+    /** The dataset built from the package's embedded data. */
+    static embedded(): Dataset;
+    /** Phases a source acts in, unioned across its phase-mappings. */
+    phasesFor(sourceType: string, sourceId: string): Phase[];
+    /** Units that list the given ability id. */
+    unitsWithAbility(abilityId: string): UnitView[];
+    /** Units that list the given weapon id. */
+    unitsWithWeapon(weaponId: string): UnitView[];
+    private buildIndexes;
+}

package/dist/data/dataset.js

@@ -0,0 +1,134 @@
+import { Collection } from "./collection.js";
+import { AbilityView, FactionView, UnitView, WeaponView } from "./entities.js";
+import { emptyRawData } from "./types.js";
+import { RAW_DATA } from "./bundle.generated.js";
+/** The whole dataset, with linked accessors over every entity collection. */
+export class Dataset {
+    // Richly-linked collections.
+    units;
+    weapons;
+    factions;
+    abilities;
+    // Id-bearing collections without bespoke views (records returned as-is).
+    detachments;
+    enhancements;
+    stratagems;
+    wargearOptions;
+    missions;
+    missionMatchups;
+    secondaryCards;
+    deploymentPatterns;
+    forceDispositions;
+    resourcePools;
+    // Id-less collections, exposed as plain arrays.
+    leaderAttachments;
+    unitCompositions;
+    gameVersions;
+    timingFlags;
+    interactionFlags;
+    phaseMappings;
+    /** `source_type:source_id` → unioned phases. */
+    phaseIndex = new Map();
+    /** ability id → units that list it. */
+    unitsByAbility = new Map();
+    /** weapon id → units that list it. */
+    unitsByWeapon = new Map();
+    constructor(raw = emptyRawData()) {
+        this.units = new Collection({
+            items: raw.units,
+            idOf: (u) => u.id,
+            // The same unit id is shared across factions (e.g. ministorum-priest);
+            // keep each faction's copy, collapse only true within-faction duplicates.
+            dedupeKeyOf: (u) => `${u.faction_id}::${u.id}`,
+            nameOf: (u) => u.name,
+            factionOf: (u) => u.faction_id,
+            wrap: (u) => new UnitView(u, this),
+        });
+        this.weapons = new Collection({
+            items: raw.weapons,
+            idOf: (w) => w.id,
+            nameOf: (w) => w.name,
+            wrap: (w) => new WeaponView(w, this),
+        });
+        this.factions = new Collection({
+            items: raw.factions,
+            idOf: (f) => f.id,
+            nameOf: (f) => f.name,
+            wrap: (f) => new FactionView(f, this),
+        });
+        this.abilities = new Collection({
+            items: raw.abilities,
+            idOf: (a) => a.ability_id,
+            nameOf: (a) => a.name,
+            factionOf: (a) => a.faction_id,
+            wrap: (a) => new AbilityView(a, this),
+        });
+        this.detachments = idCollection(raw.detachments, (d) => d.faction_id);
+        this.enhancements = idCollection(raw.enhancements);
+        this.stratagems = idCollection(raw.stratagems);
+        this.wargearOptions = idCollection(raw.wargearOptions);
+        this.missions = idCollection(raw.missions);
+        this.missionMatchups = idCollection(raw.missionMatchups);
+        this.secondaryCards = idCollection(raw.secondaryCards);
+        this.deploymentPatterns = idCollection(raw.deploymentPatterns);
+        this.forceDispositions = idCollection(raw.forceDispositions);
+        this.resourcePools = idCollection(raw.resourcePools);
+        this.leaderAttachments = raw.leaderAttachments;
+        this.unitCompositions = raw.unitCompositions;
+        this.gameVersions = raw.gameVersions;
+        this.timingFlags = raw.timingFlags;
+        this.interactionFlags = raw.interactionFlags;
+        this.phaseMappings = raw.phaseMappings;
+        this.buildIndexes(raw);
+    }
+    /** The dataset built from the package's embedded data. */
+    static embedded() {
+        return new Dataset(RAW_DATA);
+    }
+    /** Phases a source acts in, unioned across its phase-mappings. */
+    phasesFor(sourceType, sourceId) {
+        return this.phaseIndex.get(`${sourceType}:${sourceId}`) ?? [];
+    }
+    /** Units that list the given ability id. */
+    unitsWithAbility(abilityId) {
+        return (this.unitsByAbility.get(abilityId) ?? []).map((u) => new UnitView(u, this));
+    }
+    /** Units that list the given weapon id. */
+    unitsWithWeapon(weaponId) {
+        return (this.unitsByWeapon.get(weaponId) ?? []).map((u) => new UnitView(u, this));
+    }
+    buildIndexes(raw) {
+        for (const pm of raw.phaseMappings) {
+            const key = `${pm.source_type}:${pm.source_id}`;
+            const existing = this.phaseIndex.get(key) ?? [];
+            for (const phase of pm.phases) {
+                if (!existing.includes(phase))
+                    existing.push(phase);
+            }
+            this.phaseIndex.set(key, existing);
+        }
+        for (const unit of raw.units) {
+            for (const abilityId of unit.ability_ids ?? [])
+                push(this.unitsByAbility, abilityId, unit);
+            for (const weaponId of unit.weapon_ids ?? [])
+                push(this.unitsByWeapon, weaponId, unit);
+        }
+    }
+}
+/** Build a passthrough collection for an id-bearing record type. */
+function idCollection(items, factionOf) {
+    return new Collection({
+        items,
+        idOf: (i) => i.id,
+        nameOf: (i) => i.name,
+        factionOf,
+        wrap: (i) => i,
+    });
+}
+function push(map, key, value) {
+    const existing = map.get(key);
+    if (existing)
+        existing.push(value);
+    else
+        map.set(key, [value]);
+}

package/dist/data/entities.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Linked views over the four richly-connected entity types. Each wraps a raw
+ * generated record and resolves its relationships lazily against the owning
+ * {@link Dataset}; the full underlying record is always available via `.raw`.
+ *
+ * @packageDocumentation
+ */
+import type { AbilityDSLEntry, Faction, Phase, Unit, Weapon } from "../generated.js";
+import type { Dataset } from "./dataset.js";
+/** A unit, linked to its faction, weapons, and abilities. */
+export declare class UnitView {
+    /** The full generated `Unit` record. */
+    readonly raw: Unit;
+    private readonly ds;
+    constructor(
+    /** The full generated `Unit` record. */
+    raw: Unit, ds: Dataset);
+    get id(): string;
+    get name(): string;
+    /** The unit's faction, or `undefined` if its `faction_id` is unknown. */
+    get faction(): FactionView | undefined;
+    /** Weapons referenced by `weapon_ids`; unresolved ids are skipped. */
+    get weapons(): WeaponView[];
+    /** Abilities referenced by `ability_ids`; unresolved ids are skipped. */
+    get abilities(): AbilityView[];
+}
+/**
+ * An ability, linked to the phases it acts in and the units that have it.
+ *
+ * Phases are not stored on the ability — they live in `phase-mappings` records.
+ *
+ * @example
+ * units.find("Kharn")!.abilities
+ *   .filter(a => a.phases.includes("shooting"));
+ */
+export declare class AbilityView {
+    /** The full generated ability record. */
+    readonly raw: AbilityDSLEntry;
+    private readonly ds;
+    constructor(
+    /** The full generated ability record. */
+    raw: AbilityDSLEntry, ds: Dataset);
+    /** The ability's id (`ability_id` in the raw record). */
+    get id(): string;
+    get name(): string;
+    /** Game phases this ability acts in, unioned across its phase-mappings. */
+    get phases(): Phase[];
+    /** Units that list this ability in their `ability_ids`. */
+    get units(): UnitView[];
+}
+/** A weapon, linked to the units that carry it. */
+export declare class WeaponView {
+    /** The full generated `Weapon` record. */
+    readonly raw: Weapon;
+    private readonly ds;
+    constructor(
+    /** The full generated `Weapon` record. */
+    raw: Weapon, ds: Dataset);
+    get id(): string;
+    get name(): string;
+    /** Units that list this weapon in their `weapon_ids`. */
+    get units(): UnitView[];
+}
+/** A faction, linked to its units and the records scoped to it. */
+export declare class FactionView {
+    /** The full generated `Faction` record. */
+    readonly raw: Faction;
+    private readonly ds;
+    constructor(
+    /** The full generated `Faction` record. */
+    raw: Faction, ds: Dataset);
+    get id(): string;
+    get name(): string;
+    /** Units whose `faction_id` is this faction (may be empty for successors). */
+    get units(): UnitView[];
+    /** Faction-scoped abilities (abilities whose `faction_id` is this faction). */
+    get abilities(): AbilityView[];
+    /** Distinct weapons carried by this faction's units. */
+    get weapons(): WeaponView[];
+}

package/dist/data/entities.js

@@ -0,0 +1,133 @@
+/** A unit, linked to its faction, weapons, and abilities. */
+export class UnitView {
+    raw;
+    ds;
+    constructor(
+    /** The full generated `Unit` record. */
+    raw, ds) {
+        this.raw = raw;
+        this.ds = ds;
+    }
+    get id() {
+        return this.raw.id;
+    }
+    get name() {
+        return this.raw.name;
+    }
+    /** The unit's faction, or `undefined` if its `faction_id` is unknown. */
+    get faction() {
+        return this.ds.factions.get(this.raw.faction_id);
+    }
+    /** Weapons referenced by `weapon_ids`; unresolved ids are skipped. */
+    get weapons() {
+        return resolveAll(this.raw.weapon_ids, (id) => this.ds.weapons.get(id));
+    }
+    /** Abilities referenced by `ability_ids`; unresolved ids are skipped. */
+    get abilities() {
+        return resolveAll(this.raw.ability_ids, (id) => this.ds.abilities.get(id));
+    }
+}
+/**
+ * An ability, linked to the phases it acts in and the units that have it.
+ *
+ * Phases are not stored on the ability — they live in `phase-mappings` records.
+ *
+ * @example
+ * units.find("Kharn")!.abilities
+ *   .filter(a => a.phases.includes("shooting"));
+ */
+export class AbilityView {
+    raw;
+    ds;
+    constructor(
+    /** The full generated ability record. */
+    raw, ds) {
+        this.raw = raw;
+        this.ds = ds;
+    }
+    /** The ability's id (`ability_id` in the raw record). */
+    get id() {
+        return this.raw.ability_id;
+    }
+    get name() {
+        return this.raw.name;
+    }
+    /** Game phases this ability acts in, unioned across its phase-mappings. */
+    get phases() {
+        return this.ds.phasesFor("ability", this.raw.ability_id);
+    }
+    /** Units that list this ability in their `ability_ids`. */
+    get units() {
+        return this.ds.unitsWithAbility(this.raw.ability_id);
+    }
+}
+/** A weapon, linked to the units that carry it. */
+export class WeaponView {
+    raw;
+    ds;
+    constructor(
+    /** The full generated `Weapon` record. */
+    raw, ds) {
+        this.raw = raw;
+        this.ds = ds;
+    }
+    get id() {
+        return this.raw.id;
+    }
+    get name() {
+        return this.raw.name;
+    }
+    /** Units that list this weapon in their `weapon_ids`. */
+    get units() {
+        return this.ds.unitsWithWeapon(this.raw.id);
+    }
+}
+/** A faction, linked to its units and the records scoped to it. */
+export class FactionView {
+    raw;
+    ds;
+    constructor(
+    /** The full generated `Faction` record. */
+    raw, ds) {
+        this.raw = raw;
+        this.ds = ds;
+    }
+    get id() {
+        return this.raw.id;
+    }
+    get name() {
+        return this.raw.name;
+    }
+    /** Units whose `faction_id` is this faction (may be empty for successors). */
+    get units() {
+        return this.ds.units.byFaction(this.raw.id);
+    }
+    /** Faction-scoped abilities (abilities whose `faction_id` is this faction). */
+    get abilities() {
+        return this.ds.abilities.byFaction(this.raw.id);
+    }
+    /** Distinct weapons carried by this faction's units. */
+    get weapons() {
+        const seen = new Set();
+        const out = [];
+        for (const unit of this.units) {
+            for (const weapon of unit.weapons) {
+                if (seen.has(weapon.id))
+                    continue;
+                seen.add(weapon.id);
+                out.push(weapon);
+            }
+        }
+        return out;
+    }
+}
+/** Resolve a list of ids, dropping any that don't resolve. */
+function resolveAll(ids, get) {
+    const out = [];
+    for (const id of ids ?? []) {
+        const v = get(id);
+        if (v !== undefined)
+            out.push(v);
+    }
+    return out;
+}

package/dist/data/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The linked, typed 40kdc dataset.
+ *
+ * The default {@link dataset} is built once from the data embedded in this
+ * package; the top-level collections below are its accessors, re-exported for
+ * the ergonomic one-liner form.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * import { units } from "@alpaca-software/40kdc-data";
+ *
+ * units.find("Kharn")!.abilities
+ *   .filter(a => a.phases.includes("shooting"))
+ *   .map(a => a.id); // ["berzerker-frenzy"]
+ *
+ * @example
+ * import { factions } from "@alpaca-software/40kdc-data";
+ *
+ * factions.find("World Eaters")!.units.length;
+ */
+export { Dataset } from "./dataset.js";
+export { Collection } from "./collection.js";
+export type { CollectionConfig } from "./collection.js";
+export { UnitView, AbilityView, WeaponView, FactionView } from "./entities.js";
+export { normalizeName } from "./normalize.js";
+export { emptyRawData } from "./types.js";
+export type { RawData } from "./types.js";
+import { Dataset } from "./dataset.js";
+/** The dataset built from this package's embedded data. */
+export declare const dataset: Dataset;
+/** All units, linked to their faction, weapons, and abilities. */
+export declare const units: import("./collection.js").Collection<import("../generated.js").Unit, import("./entities.js").UnitView>;
+/** All weapons, linked to the units that carry them. */
+export declare const weapons: import("./collection.js").Collection<import("../generated.js").Weapon, import("./entities.js").WeaponView>;
+/** All factions, linked to their units, abilities, and weapons. */
+export declare const factions: import("./collection.js").Collection<import("../generated.js").Faction, import("./entities.js").FactionView>;
+/** All abilities, linked to their phases and the units that have them. */
+export declare const abilities: import("./collection.js").Collection<import("../generated.js").AbilityDSLEntry, import("./entities.js").AbilityView>;
+/** All detachments. */
+export declare const detachments: import("./collection.js").Collection<import("../generated.js").Detachment, import("../generated.js").Detachment>;
+/** All enhancements. */
+export declare const enhancements: import("./collection.js").Collection<import("../generated.js").Enhancement, import("../generated.js").Enhancement>;
+/** All stratagems. */
+export declare const stratagems: import("./collection.js").Collection<import("../generated.js").Stratagem, import("../generated.js").Stratagem>;
+/** All wargear options. */
+export declare const wargearOptions: import("./collection.js").Collection<import("../generated.js").WargearOption, import("../generated.js").WargearOption>;
+/** All missions. */
+export declare const missions: import("./collection.js").Collection<import("../generated.js").Mission, import("../generated.js").Mission>;
+/** All mission matchups. */
+export declare const missionMatchups: import("./collection.js").Collection<import("../generated.js").MissionMatchup, import("../generated.js").MissionMatchup>;
+/** All secondary mission cards. */
+export declare const secondaryCards: import("./collection.js").Collection<import("../generated.js").SecondaryCard, import("../generated.js").SecondaryCard>;
+/** All deployment patterns. */
+export declare const deploymentPatterns: import("./collection.js").Collection<import("../generated.js").DeploymentPattern, import("../generated.js").DeploymentPattern>;
+/** All force dispositions. */
+export declare const forceDispositions: import("./collection.js").Collection<import("../generated.js").ForceDisposition, import("../generated.js").ForceDisposition>;
+/** All resource pools. */
+export declare const resourcePools: import("./collection.js").Collection<import("../generated.js").ResourcePool, import("../generated.js").ResourcePool>;