@archivist-gg/dnd5e 0.1.0

package/dist/chunk-ZLG6FQFB.js

@@ -0,0 +1,237 @@
+import {
+  CONDITION_SLUGS
+} from "./chunk-TZK36BU7.js";
+
+// src/pc/pc.schema.ts
+import { z } from "zod";
+var conditionSlugEnum = z.enum(CONDITION_SLUGS);
+var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
+var skillEnum = z.enum([
+  "acrobatics",
+  "animal-handling",
+  "arcana",
+  "athletics",
+  "deception",
+  "history",
+  "insight",
+  "intimidation",
+  "investigation",
+  "medicine",
+  "nature",
+  "perception",
+  "performance",
+  "persuasion",
+  "religion",
+  "sleight-of-hand",
+  "stealth",
+  "survival"
+]);
+var proficiencyTri = z.enum(["none", "proficient", "expertise"]);
+var slotEnum = z.enum(["mainhand", "offhand", "armor", "shield"]);
+var equipmentEntryOverridesSchema = z.object({
+  name: z.string().optional(),
+  bonus: z.number().int().optional(),
+  damage_bonus: z.number().int().optional(),
+  extra_damage: z.string().optional(),
+  ac_bonus: z.number().int().optional(),
+  action: z.enum(["action", "bonus-action", "reaction", "free", "special"]).optional(),
+  range: z.string().optional()
+}).strict();
+var equipmentEntryStateSchema = z.object({
+  charges: z.object({
+    current: z.number().int().nonnegative(),
+    max: z.number().int().nonnegative()
+  }).optional(),
+  recovery: z.object({
+    amount: z.string(),
+    reset: z.enum(["dawn", "short", "long", "special"])
+  }).optional(),
+  depletion_risk: z.object({
+    trigger: z.string(),
+    roll: z.string(),
+    threshold: z.number().int(),
+    effect: z.string()
+  }).optional()
+}).strict();
+var equipmentEntrySchema = z.object({
+  item: z.string().min(1),
+  equipped: z.boolean().optional(),
+  attuned: z.boolean().optional(),
+  qty: z.number().int().positive().optional(),
+  notes: z.string().optional(),
+  slot: slotEnum.nullable().optional(),
+  overrides: equipmentEntryOverridesSchema.optional(),
+  state: equipmentEntryStateSchema.optional(),
+  // Build-only provenance for Equipment-step-seeded gear (e.g. "builder:starting",
+  // "builder:gold-buy"). Permissive plain string; stripped by finishBuild so a
+  // finished file never carries it.
+  granted_by: z.string().optional()
+});
+var characterOverridesSchema = z.object({
+  scores: z.partialRecord(abilityEnum, z.number().int()).optional(),
+  saves: z.partialRecord(abilityEnum, z.object({
+    bonus: z.number().int().optional(),
+    proficient: z.boolean().optional()
+  })).optional(),
+  skills: z.partialRecord(skillEnum, z.object({
+    bonus: z.number().int(),
+    proficiency: proficiencyTri.optional()
+  })).optional(),
+  passives: z.object({
+    perception: z.number().int().optional(),
+    investigation: z.number().int().optional(),
+    insight: z.number().int().optional()
+  }).partial().optional(),
+  hp: z.object({ max: z.number().int().positive().optional() }).optional(),
+  ac: z.number().int().optional(),
+  speed: z.number().int().optional(),
+  initiative: z.number().int().optional(),
+  spellcasting: z.object({
+    saveDC: z.number().int().optional(),
+    attackBonus: z.number().int().optional()
+  }).optional(),
+  spell_slots: z.record(z.coerce.number().int(), z.number().int().nonnegative()).optional(),
+  attunement_limit: z.number().int().nonnegative().optional()
+}).default({});
+var characterStateSchema = z.object({
+  hp: z.object({
+    current: z.number().int(),
+    max: z.number().int(),
+    temp: z.number().int().nonnegative()
+  }),
+  hit_dice: z.record(z.string(), z.object({
+    used: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative()
+  })).default({}),
+  spell_slots: z.record(z.coerce.number().int(), z.object({
+    used: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative()
+  })).default({}),
+  spell_slots_pact: z.object({
+    level: z.number().int().nonnegative(),
+    used: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative()
+  }).optional(),
+  concentration: z.string().nullable().default(null),
+  conditions: z.array(conditionSlugEnum).default([]),
+  exhaustion: z.number().int().min(0).max(6).default(0),
+  death_saves: z.object({
+    successes: z.number().int().min(0).max(3),
+    failures: z.number().int().min(0).max(3)
+  }).optional(),
+  inspiration: z.number().int().nonnegative().default(0),
+  currency: z.object({
+    cp: z.number().int().nonnegative(),
+    sp: z.number().int().nonnegative(),
+    ep: z.number().int().nonnegative(),
+    gp: z.number().int().nonnegative(),
+    pp: z.number().int().nonnegative()
+  }).optional(),
+  feature_uses: z.record(z.string(), z.object({
+    used: z.number().int().nonnegative(),
+    max: z.number().int().nonnegative()
+  })).default({}),
+  // Phase 3 activatable buffs: ids/slugs of activatable features/boons that are
+  // currently toggled on. Their effects fold into recalc only while listed here.
+  active_buffs: z.array(z.string()).optional(),
+  attuned_items: z.array(z.string()).optional()
+});
+var choiceValueSchema = z.union([
+  z.string(),
+  z.array(z.string()),
+  z.record(z.string(), z.unknown())
+]).catch((ctx) => ctx.value);
+var classEntrySchema = z.object({
+  name: z.string().min(1),
+  level: z.number().int().min(1).max(20),
+  subclass: z.string().nullable().default(null),
+  // Per-level record is also catch-guarded so a non-object level value
+  // (e.g. `choices: {1: null}` or `{1: "foo"}`) survives the parse instead
+  // of failing the whole character.
+  choices: z.record(
+    z.coerce.number().int(),
+    z.record(z.string(), choiceValueSchema).catch((ctx) => ctx.value)
+    // type-only cast; value preserved at runtime
+  ).default({})
+});
+var spellOverrideSchema = z.object({
+  slug: z.string().min(1),
+  overrides: z.record(z.string(), z.unknown()).default({})
+});
+var knownSpellObjectSchema = z.object({
+  spell: z.string().min(1),
+  class: z.string().optional(),
+  source: z.enum(["class", "feat", "item", "race", "domain"]).optional(),
+  prepared: z.boolean().optional(),
+  always_prepared: z.boolean().optional()
+}).strict();
+var knownSpellEntrySchema = z.union([z.string().min(1), knownSpellObjectSchema]);
+var characterSchema = z.object({
+  name: z.string().min(1),
+  edition: z.enum(["2014", "2024"]),
+  // Builder-draft marker (SP2 Plan 3). NO default: absent on every existing
+  // file and stays absent on save; present+true only while the file is an
+  // unfinished Builder draft. Finish deletes the key (see finishBuild).
+  builder: z.boolean().optional(),
+  alignment: z.string().optional(),
+  age: z.string().optional(),
+  race: z.string().nullable().default(null),
+  subrace: z.string().nullable().default(null),
+  background: z.string().nullable().default(null),
+  // Relaxed from .min(1) for build-in-progress drafts: the Builder is the only
+  // producer of class-less files, and recalc degrades gracefully (HP/derivation
+  // fall back with warnings) when no class is present. See SP2 spec §5/§9.
+  class: z.array(classEntrySchema).default([]),
+  // Race/background decision selections, keyed `race:<id>` / `background:<id>`
+  // (SP2 Plan 3). Permissive value arm mirrors per-level class choices.
+  origin_choices: z.record(z.string(), choiceValueSchema).default({}),
+  abilities: z.object({
+    str: z.number().int(),
+    dex: z.number().int(),
+    con: z.number().int(),
+    int: z.number().int(),
+    wis: z.number().int(),
+    cha: z.number().int()
+  }),
+  ability_method: z.enum(["standard-array", "point-buy", "archivist-point-buy", "rolled", "manual"]),
+  // Persisted Roll-method ability pool (SP2 Plan 5). NO default — absent on
+  // every existing/finished file and stays absent on save; present only while
+  // the file is an unfinished Builder draft in `rolled` mode. Finish deletes
+  // the key (see finishBuild). Permissive: a plain int array, no length pin
+  // (re-rolls always write six, but legacy/hand-edited files may vary).
+  builder_rolls: z.array(z.number().int()).optional(),
+  // Persisted Equipment-step mode (SP2). NO default — absent on every
+  // existing/finished file and stays absent on save; present only while the file
+  // is an unfinished Builder draft. Finish deletes the key (see finishBuild).
+  builder_equipment_mode: z.enum(["starting", "gold", "empty"]).optional(),
+  skills: z.object({
+    proficient: z.array(skillEnum).default([]),
+    expertise: z.array(skillEnum).default([])
+  }).default({ proficient: [], expertise: [] }),
+  spells: z.object({
+    known: z.array(knownSpellEntrySchema).default([]),
+    overrides: z.array(spellOverrideSchema).default([]),
+    view: z.enum(["by-level", "table"]).optional()
+  }).default({ known: [], overrides: [] }),
+  equipment: z.array(equipmentEntrySchema).default([]),
+  overrides: characterOverridesSchema,
+  currency: z.object({
+    cp: z.number().int().nonnegative(),
+    sp: z.number().int().nonnegative(),
+    ep: z.number().int().nonnegative(),
+    gp: z.number().int().nonnegative(),
+    pp: z.number().int().nonnegative()
+  }).optional(),
+  notes: z.string().optional(),
+  defenses: z.object({
+    resistances: z.array(z.string()).default([]),
+    immunities: z.array(z.string()).default([]),
+    vulnerabilities: z.array(z.string()).default([]),
+    condition_immunities: z.array(z.string()).default([])
+  }).partial().optional(),
+  state: characterStateSchema
+});
+
+export {
+  characterSchema
+};

package/dist/chunk-ZMR77DDL.js

@@ -0,0 +1,18 @@
+import {
+  parseArmor
+} from "./chunk-HCP3GMHS.js";
+
+// src/armor/armor.codec.ts
+import yaml from "js-yaml";
+var armorCodec = {
+  parse(doc) {
+    return parseArmor(doc.body);
+  },
+  serialize(entity) {
+    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  armorCodec
+};

package/dist/class/class.codec.d.ts

@@ -0,0 +1,10 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { ClassEntity } from "./class.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseClass`, which validates
+ * against `classEntitySchema`. `class.types` is this entity's dnd5e home for
+ * `SpellcastingConfig`/`ClassEntity` (consumed by PC + all subclass files).
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer; gate (d) verifies `yaml.dump` round-trips through `parseClass`).
+ */
+export declare const classCodec: DocCodec<ClassEntity>;

package/dist/class/class.codec.js

@@ -0,0 +1,15 @@
+import {
+  classCodec
+} from "../chunk-RVYYKYFL.js";
+import "../chunk-FUK7QSN5.js";
+import "../chunk-Z6GXV2GO.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  classCodec
+};

package/dist/class/class.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const classEntityType: EntityType;

package/dist/class/class.parser.d.ts

@@ -0,0 +1,3 @@
+import type { ClassEntity } from "./class.types.js";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseClass(source: string): ParseResult<ClassEntity>;

package/dist/class/class.parser.js

@@ -0,0 +1,14 @@
+import {
+  parseClass
+} from "../chunk-FUK7QSN5.js";
+import "../chunk-Z6GXV2GO.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseClass
+};

package/dist/class/class.schema.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+export declare const classEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    hit_die: z.ZodEnum<{
+        d6: "d6";
+        d8: "d8";
+        d10: "d10";
+        d12: "d12";
+    }>;
+    primary_abilities: z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>;
+    saving_throws: z.ZodArray<z.ZodEnum<{
+        str: "str";
+        dex: "dex";
+        con: "con";
+        int: "int";
+        wis: "wis";
+        cha: "cha";
+    }>>;
+    proficiencies: z.ZodObject<{
+        armor: z.ZodArray<z.ZodEnum<{
+            light: "light";
+            medium: "medium";
+            heavy: "heavy";
+            shield: "shield";
+        }>>;
+        weapons: z.ZodObject<{
+            fixed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            categories: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                simple: "simple";
+                martial: "martial";
+            }>>>;
+            conditional: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                category: z.ZodEnum<{
+                    simple: "simple";
+                    martial: "martial";
+                }>;
+                where_property: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        tools: z.ZodOptional<z.ZodObject<{
+            fixed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            choice: z.ZodOptional<z.ZodObject<{
+                count: z.ZodNumber;
+                from: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    skill_choices: z.ZodObject<{
+        count: z.ZodNumber;
+        from: z.ZodArray<z.ZodEnum<{
+            acrobatics: "acrobatics";
+            "animal-handling": "animal-handling";
+            arcana: "arcana";
+            athletics: "athletics";
+            deception: "deception";
+            history: "history";
+            insight: "insight";
+            intimidation: "intimidation";
+            investigation: "investigation";
+            medicine: "medicine";
+            nature: "nature";
+            perception: "perception";
+            performance: "performance";
+            persuasion: "persuasion";
+            religion: "religion";
+            "sleight-of-hand": "sleight-of-hand";
+            stealth: "stealth";
+            survival: "survival";
+        }>>;
+    }, z.core.$strip>;
+    starting_equipment: z.ZodArray<z.ZodType<import("./class.types.js").StartingEquipmentEntry, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingEquipmentEntry, unknown>>>;
+    starting_gold: z.ZodOptional<z.ZodType<import("./class.types.js").StartingGold, unknown, z.core.$ZodTypeInternals<import("./class.types.js").StartingGold, unknown>>>;
+    spellcasting: z.ZodNullable<z.ZodObject<{
+        caster_type: z.ZodEnum<{
+            pact: "pact";
+            full: "full";
+            half: "half";
+            third: "third";
+        }>;
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        preparation: z.ZodEnum<{
+            known: "known";
+            prepared: "prepared";
+        }>;
+        spell_list: z.ZodString;
+    }, z.core.$strip>>;
+    subclass_level: z.ZodNumber;
+    subclass_feature_name: z.ZodString;
+    weapon_mastery: z.ZodNullable<z.ZodObject<{
+        starting_count: z.ZodNumber;
+        scaling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+    epic_boon_level: z.ZodNullable<z.ZodNumber>;
+    table: z.ZodRecord<z.ZodString, z.ZodObject<{
+        prof_bonus: z.ZodNumber;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        feature_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    features_by_level: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        max_formula: z.ZodString;
+        scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            max: z.ZodString;
+        }, z.core.$strict>>>;
+        die: z.ZodOptional<z.ZodObject<{
+            base: z.ZodString;
+            scaling: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        reset: z.ZodEnum<{
+            "short-rest": "short-rest";
+            "long-rest": "long-rest";
+            dawn: "dawn";
+            dusk: "dusk";
+            turn: "turn";
+            round: "round";
+            custom: "custom";
+        }>;
+        consumes: z.ZodOptional<z.ZodObject<{
+            resource: z.ZodString;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
+        recovery: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            amount: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            action: z.ZodOptional<z.ZodEnum<{
+                action: "action";
+                "bonus-action": "bonus-action";
+                reaction: "reaction";
+                free: "free";
+                special: "special";
+            }>>;
+            uses: z.ZodOptional<z.ZodNumber>;
+            reset: z.ZodEnum<{
+                "short-rest": "short-rest";
+                "long-rest": "long-rest";
+                dawn: "dawn";
+                dusk: "dusk";
+                turn: "turn";
+                round: "round";
+                custom: "custom";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    selection_pools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        source: z.ZodObject<{
+            entity_type: z.ZodLiteral<"optional-feature">;
+            where: z.ZodObject<{
+                feature_type: z.ZodString;
+                available_to: z.ZodLiteral<"self">;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        count: z.ZodObject<{
+            column: z.ZodString;
+        }, z.core.$strip>;
+        replaceable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    pool_grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pool: z.ZodString;
+        grants: z.ZodArray<z.ZodObject<{
+            feature: z.ZodString;
+            at_level: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    tabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        renders: z.ZodObject<{
+            pool: z.ZodString;
+            layout: z.ZodOptional<z.ZodEnum<{
+                "spell-like": "spell-like";
+                blocks: "blocks";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;

package/dist/class/class.schema.js

@@ -0,0 +1,13 @@
+import {
+  classEntitySchema
+} from "../chunk-Z6GXV2GO.js";
+import "../chunk-4TIJKN6O.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-3DZ74AKK.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  classEntitySchema
+};

package/dist/class/class.slug.d.ts

@@ -0,0 +1,11 @@
+export declare function bareSlug(ref: string): string;
+/**
+ * Bare class name for profile / spell-`classes` lookups.
+ *
+ * Compendium-qualified slugs are `<compendium>_<name>` — e.g. `srd-5e_wizard`,
+ * `srd-2024_bard` (compendium slugs are hyphen-cased, so `_` only ever separates
+ * the compendium from the entity name). Strip that prefix to get the canonical
+ * class key (`wizard`). Hand-written/test slugs without a `_` pass through
+ * unchanged (`wizard` → `wizard`).
+ */
+export declare function baseClassName(ref: string): string;

package/dist/class/class.slug.js

@@ -0,0 +1,8 @@
+import {
+  bareSlug,
+  baseClassName
+} from "../chunk-J2RYSZMQ.js";
+export {
+  bareSlug,
+  baseClassName
+};

package/dist/class/class.types.d.ts

@@ -0,0 +1,74 @@
+import type { Feature, Ability, SkillSlug, Resource } from "@archivist-gg/dnd5e";
+import type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
+export type { StartingEquipmentEntry, StartingGold } from "@archivist-gg/dnd5e/types/equipment-grant";
+import type { SelectionPool, PoolGrant, TabDecl } from "@archivist-gg/dnd5e/types/selection-pool";
+import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+export type { Edition };
+export type ArmorCategory = "light" | "medium" | "heavy" | "shield";
+export type WeaponCategory = "simple" | "martial";
+export interface WeaponProficiency {
+    fixed?: string[];
+    categories?: WeaponCategory[];
+    conditional?: Array<{
+        category: WeaponCategory;
+        where_property: string[];
+    }>;
+}
+export interface ToolProficiency {
+    fixed?: string[];
+    choice?: {
+        count: number;
+        from: string[];
+    };
+}
+export interface ClassProficiencies {
+    armor: ArmorCategory[];
+    weapons: WeaponProficiency;
+    tools?: ToolProficiency;
+}
+export interface SkillChoices {
+    count: number;
+    from: SkillSlug[];
+}
+export type CasterType = "full" | "half" | "third" | "pact";
+export type SpellcastingPreparation = "known" | "prepared";
+export interface SpellcastingConfig {
+    caster_type: CasterType;
+    ability: Ability;
+    preparation: SpellcastingPreparation;
+    spell_list: string;
+}
+export interface WeaponMasteryConfig {
+    starting_count: number;
+    scaling?: Record<number, number>;
+}
+export interface ClassTableRow {
+    prof_bonus: number;
+    columns?: Record<string, string | number>;
+    feature_ids: string[];
+}
+export interface ClassEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    description: string;
+    hit_die: string;
+    primary_abilities: Ability[];
+    saving_throws: Ability[];
+    proficiencies: ClassProficiencies;
+    skill_choices: SkillChoices;
+    starting_equipment: StartingEquipmentEntry[];
+    starting_gold?: StartingGold;
+    spellcasting: SpellcastingConfig | null;
+    subclass_level: number;
+    subclass_feature_name: string;
+    weapon_mastery: WeaponMasteryConfig | null;
+    epic_boon_level: number | null;
+    table: Record<number, ClassTableRow>;
+    features_by_level: Record<number, Feature[]>;
+    resources: Resource[];
+    selection_pools?: SelectionPool[];
+    pool_grants?: PoolGrant[];
+    tabs?: TabDecl[];
+}

package/dist/data-srd/index.generated.d.ts

@@ -0,0 +1,7 @@
+export interface SrdMdEntry {
+    type: string;
+    slug: string;
+    name: string;
+    content: string;
+}
+export declare const SRD_MD_ENTRIES: SrdMdEntry[];