optolith-database-schema 0.17.2 → 0.18.1

package/lib/types/_IdentifierGroup.js

@@ -1 +1,340 @@
-export {};
+import { Enum, EnumCase } from "tsondb/schema/def";
+import { AdvancedCombatSpecialAbilityIdentifier, AdvancedKarmaSpecialAbilityIdentifier, AdvancedMagicalSpecialAbilityIdentifier, AdvancedSkillSpecialAbilityIdentifier, AdvantageIdentifier, AmmunitionIdentifier, AncestorGlyphIdentifier, AnimalCareIdentifier, AnimalIdentifier, AnimalShapeIdentifier, AnimalShapeSizeIdentifier, AnimistPowerIdentifier, ArcaneBardTraditionIdentifier, ArcaneDancerTraditionIdentifier, ArcaneOrbEnchantmentIdentifier, ArmorIdentifier, AspectIdentifier, AttireEnchantmentIdentifier, AttributeIdentifier, BandageOrRemedyIdentifier, BlessedTraditionIdentifier, BlessingIdentifier, BookIdentifier, BowlEnchantmentIdentifier, BrawlingSpecialAbilityIdentifier, CantripIdentifier, CauldronEnchantmentIdentifier, CeremonialItemIdentifier, CeremonialItemSpecialAbilityIdentifier, CeremonyIdentifier, ChronicleEnchantmentIdentifier, CloseCombatTechniqueIdentifier, ClothesIdentifier, CombatSpecialAbilityIdentifier, CombatStyleSpecialAbilityIdentifier, CommandSpecialAbilityIdentifier, ContainerIdentifier, CultureIdentifier, CurseIdentifier, DaggerRitualIdentifier, DisadvantageIdentifier, DiseaseIdentifier, DominationRitualIdentifier, ElementIdentifier, ElixirIdentifier, ElvenMagicalSongIdentifier, EquipmentOfBlessedOnesIdentifier, FamiliarSpecialAbilityIdentifier, FatePointSexSpecialAbilityIdentifier, FatePointSpecialAbilityIdentifier, FocusRuleIdentifier, FoolsHatEnchantmentIdentifier, GemOrPreciousStoneIdentifier, GeneralIdentifier, GeneralSpecialAbilityIdentifier, GeodeRitualIdentifier, IlluminationLightSourceIdentifier, IlluminationRefillsOrSuppliesIdentifier, InstrumentEnchantmentIdentifier, JesterTrickIdentifier, JewelryIdentifier, KarmaSpecialAbilityIdentifier, KrallenkettenzauberIdentifier, LanguageIdentifier, LiebesspielzeugIdentifier, LiturgicalChantIdentifier, LiturgicalStyleSpecialAbilityIdentifier, LuxuryGoodIdentifier, LycantropicGiftIdentifier, MagicalArtifactIdentifier, MagicalDanceIdentifier, MagicalMelodyIdentifier, MagicalRuneIdentifier, MagicalSignIdentifier, MagicalSpecialAbilityIdentifier, MagicalTraditionIdentifier, MagicStyleSpecialAbilityIdentifier, MusicalInstrumentIdentifier, OptionalRuleIdentifier, OrbEnchantmentIdentifier, OrienteeringAidIdentifier, PactGiftIdentifier, PatronIdentifier, PoisonIdentifier, PropertyIdentifier, ProtectiveWardingCircleSpecialAbilityIdentifier, RaceIdentifier, RangedCombatTechniqueIdentifier, RingEnchantmentIdentifier, RitualIdentifier, RopeOrChainIdentifier, ScriptIdentifier, SermonIdentifier, SexPracticeIdentifier, SexSpecialAbilityIdentifier, SickleRitualIdentifier, SikaryanDrainSpecialAbilityIdentifier, SkillApplicationIdentifier, SkillIdentifier, SkillStyleSpecialAbilityIdentifier, SpellIdentifier, SpellSwordEnchantmentIdentifier, StaffEnchantmentIdentifier, StationeryIdentifier, TargetCategoryIdentifier, ThievesToolIdentifier, ToolOfTheTradeIdentifier, ToyEnchantmentIdentifier, TradeSecretIdentifier, TravelGearOrToolIdentifier, TrinkhornzauberIdentifier, VampiricGiftIdentifier, VehicleIdentifier, VisionIdentifier, WandEnchantmentIdentifier, WeaponAccessoryIdentifier, WeaponEnchantmentIdentifier, WeaponIdentifier, ZibiljaRitualIdentifier, } from "./_Identifier.js";
+export const ActivatableIdentifier = Enum(import.meta.url, {
+    name: "ActivatableIdentifier",
+    values: () => ({
+        Advantage: EnumCase({ type: AdvantageIdentifier() }),
+        Disadvantage: EnumCase({ type: DisadvantageIdentifier() }),
+        AdvancedCombatSpecialAbility: EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        AdvancedKarmaSpecialAbility: EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
+        AdvancedMagicalSpecialAbility: EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
+        AdvancedSkillSpecialAbility: EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+        AncestorGlyph: EnumCase({ type: AncestorGlyphIdentifier() }),
+        ArcaneOrbEnchantment: EnumCase({ type: ArcaneOrbEnchantmentIdentifier() }),
+        AttireEnchantment: EnumCase({ type: AttireEnchantmentIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+        BowlEnchantment: EnumCase({ type: BowlEnchantmentIdentifier() }),
+        BrawlingSpecialAbility: EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
+        CauldronEnchantment: EnumCase({ type: CauldronEnchantmentIdentifier() }),
+        CeremonialItemSpecialAbility: EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
+        ChronicleEnchantment: EnumCase({ type: ChronicleEnchantmentIdentifier() }),
+        CombatSpecialAbility: EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+        CombatStyleSpecialAbility: EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+        CommandSpecialAbility: EnumCase({ type: CommandSpecialAbilityIdentifier() }),
+        DaggerRitual: EnumCase({ type: DaggerRitualIdentifier() }),
+        FamiliarSpecialAbility: EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
+        FatePointSexSpecialAbility: EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
+        FatePointSpecialAbility: EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
+        FoolsHatEnchantment: EnumCase({ type: FoolsHatEnchantmentIdentifier() }),
+        GeneralSpecialAbility: EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
+        InstrumentEnchantment: EnumCase({ type: InstrumentEnchantmentIdentifier() }),
+        KarmaSpecialAbility: EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
+        Krallenkettenzauber: EnumCase({ type: KrallenkettenzauberIdentifier() }),
+        LiturgicalStyleSpecialAbility: EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
+        LycantropicGift: EnumCase({ type: LycantropicGiftIdentifier() }),
+        MagicalSign: EnumCase({ type: MagicalSignIdentifier() }),
+        MagicalSpecialAbility: EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        MagicStyleSpecialAbility: EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
+        OrbEnchantment: EnumCase({ type: OrbEnchantmentIdentifier() }),
+        PactGift: EnumCase({ type: PactGiftIdentifier() }),
+        ProtectiveWardingCircleSpecialAbility: EnumCase({
+            type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
+        }),
+        RingEnchantment: EnumCase({ type: RingEnchantmentIdentifier() }),
+        Sermon: EnumCase({ type: SermonIdentifier() }),
+        SexSpecialAbility: EnumCase({ type: SexSpecialAbilityIdentifier() }),
+        SickleRitual: EnumCase({ type: SickleRitualIdentifier() }),
+        SikaryanDrainSpecialAbility: EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
+        SkillStyleSpecialAbility: EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
+        SpellSwordEnchantment: EnumCase({ type: SpellSwordEnchantmentIdentifier() }),
+        StaffEnchantment: EnumCase({ type: StaffEnchantmentIdentifier() }),
+        ToyEnchantment: EnumCase({ type: ToyEnchantmentIdentifier() }),
+        Trinkhornzauber: EnumCase({ type: TrinkhornzauberIdentifier() }),
+        VampiricGift: EnumCase({ type: VampiricGiftIdentifier() }),
+        Vision: EnumCase({ type: VisionIdentifier() }),
+        WandEnchantment: EnumCase({ type: WandEnchantmentIdentifier() }),
+        WeaponEnchantment: EnumCase({ type: WeaponEnchantmentIdentifier() }),
+    }),
+});
+export const NewSkillApplicationOrUseParentIdentifier = Enum(import.meta.url, {
+    name: "NewSkillApplicationOrUseParentIdentifier",
+    values: () => ({
+        GeneralSelectOption: EnumCase({ type: GeneralIdentifier() }),
+        Advantage: EnumCase({ type: AdvantageIdentifier() }),
+        Disadvantage: EnumCase({ type: DisadvantageIdentifier() }),
+        AdvancedCombatSpecialAbility: EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        AdvancedKarmaSpecialAbility: EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
+        AdvancedMagicalSpecialAbility: EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
+        AdvancedSkillSpecialAbility: EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+        CeremonialItemSpecialAbility: EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
+        CombatSpecialAbility: EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+        CombatStyleSpecialAbility: EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+        FatePointSpecialAbility: EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
+        GeneralSpecialAbility: EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
+        LiturgicalStyleSpecialAbility: EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
+        MagicalSpecialAbility: EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        MagicStyleSpecialAbility: EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
+        SexSpecialAbility: EnumCase({ type: SexSpecialAbilityIdentifier() }),
+    }),
+});
+export const SpecialAbilityIdentifier = Enum(import.meta.url, {
+    name: "SpecialAbilityIdentifier",
+    values: () => ({
+        AdvancedCombatSpecialAbility: EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        AdvancedKarmaSpecialAbility: EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
+        AdvancedMagicalSpecialAbility: EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
+        AdvancedSkillSpecialAbility: EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+        AncestorGlyph: EnumCase({ type: AncestorGlyphIdentifier() }),
+        ArcaneOrbEnchantment: EnumCase({ type: ArcaneOrbEnchantmentIdentifier() }),
+        AttireEnchantment: EnumCase({ type: AttireEnchantmentIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+        BowlEnchantment: EnumCase({ type: BowlEnchantmentIdentifier() }),
+        BrawlingSpecialAbility: EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
+        CauldronEnchantment: EnumCase({ type: CauldronEnchantmentIdentifier() }),
+        CeremonialItemSpecialAbility: EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
+        ChronicleEnchantment: EnumCase({ type: ChronicleEnchantmentIdentifier() }),
+        CombatSpecialAbility: EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+        CombatStyleSpecialAbility: EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+        CommandSpecialAbility: EnumCase({ type: CommandSpecialAbilityIdentifier() }),
+        DaggerRitual: EnumCase({ type: DaggerRitualIdentifier() }),
+        FamiliarSpecialAbility: EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
+        FatePointSexSpecialAbility: EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
+        FatePointSpecialAbility: EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
+        FoolsHatEnchantment: EnumCase({ type: FoolsHatEnchantmentIdentifier() }),
+        GeneralSpecialAbility: EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
+        InstrumentEnchantment: EnumCase({ type: InstrumentEnchantmentIdentifier() }),
+        KarmaSpecialAbility: EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
+        Krallenkettenzauber: EnumCase({ type: KrallenkettenzauberIdentifier() }),
+        LiturgicalStyleSpecialAbility: EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
+        LycantropicGift: EnumCase({ type: LycantropicGiftIdentifier() }),
+        MagicalSign: EnumCase({ type: MagicalSignIdentifier() }),
+        MagicalSpecialAbility: EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        MagicStyleSpecialAbility: EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
+        OrbEnchantment: EnumCase({ type: OrbEnchantmentIdentifier() }),
+        PactGift: EnumCase({ type: PactGiftIdentifier() }),
+        ProtectiveWardingCircleSpecialAbility: EnumCase({
+            type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
+        }),
+        RingEnchantment: EnumCase({ type: RingEnchantmentIdentifier() }),
+        Sermon: EnumCase({ type: SermonIdentifier() }),
+        SexSpecialAbility: EnumCase({ type: SexSpecialAbilityIdentifier() }),
+        SickleRitual: EnumCase({ type: SickleRitualIdentifier() }),
+        SikaryanDrainSpecialAbility: EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
+        SkillStyleSpecialAbility: EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
+        SpellSwordEnchantment: EnumCase({ type: SpellSwordEnchantmentIdentifier() }),
+        StaffEnchantment: EnumCase({ type: StaffEnchantmentIdentifier() }),
+        ToyEnchantment: EnumCase({ type: ToyEnchantmentIdentifier() }),
+        Trinkhornzauber: EnumCase({ type: TrinkhornzauberIdentifier() }),
+        VampiricGift: EnumCase({ type: VampiricGiftIdentifier() }),
+        Vision: EnumCase({ type: VisionIdentifier() }),
+        WandEnchantment: EnumCase({ type: WandEnchantmentIdentifier() }),
+        WeaponEnchantment: EnumCase({ type: WeaponEnchantmentIdentifier() }),
+    }),
+});
+export const CombatRelatedSpecialAbilityIdentifier = Enum(import.meta.url, {
+    name: "CombatRelatedSpecialAbilityIdentifier",
+    values: () => ({
+        CombatSpecialAbility: EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+        CombatStyleSpecialAbility: EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+        AdvancedCombatSpecialAbility: EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        CommandSpecialAbility: EnumCase({ type: CommandSpecialAbilityIdentifier() }),
+    }),
+});
+export const TraditionIdentifier = Enum(import.meta.url, {
+    name: "TraditionIdentifier",
+    values: () => ({
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+    }),
+});
+export const RatedIdentifier = Enum(import.meta.url, {
+    name: "RatedIdentifier",
+    values: () => ({
+        Attribute: EnumCase({ type: AttributeIdentifier() }),
+        Skill: EnumCase({ type: SkillIdentifier() }),
+        CloseCombatTechnique: EnumCase({ type: CloseCombatTechniqueIdentifier() }),
+        RangedCombatTechnique: EnumCase({ type: RangedCombatTechniqueIdentifier() }),
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+    }),
+});
+export const SkillishIdentifier = Enum(import.meta.url, {
+    name: "SkillishIdentifier",
+    values: () => ({
+        Skill: EnumCase({ type: SkillIdentifier() }),
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+    }),
+});
+export const AdvancedSpecialAbilityRestrictedOptionIdentifier = Enum(import.meta.url, {
+    name: "AdvancedSpecialAbilityRestrictedOptionIdentifier",
+    values: () => ({
+        General: EnumCase({ type: GeneralIdentifier() }),
+        Skill: EnumCase({ type: SkillIdentifier() }),
+        CloseCombatTechnique: EnumCase({ type: CloseCombatTechniqueIdentifier() }),
+        RangedCombatTechnique: EnumCase({ type: RangedCombatTechniqueIdentifier() }),
+        Element: EnumCase({ type: ElementIdentifier() }),
+        Aspect: EnumCase({ type: AspectIdentifier() }),
+    }),
+});
+export const VolumePointsOptionReferenceIdentifier = Enum(import.meta.url, {
+    name: "VolumePointsOptionReferenceIdentifier",
+    values: () => ({
+        General: EnumCase({ type: GeneralIdentifier() }),
+        AnimalShapeSize: EnumCase({ type: AnimalShapeSizeIdentifier() }),
+    }),
+});
+export const CombatTechniqueIdentifier = Enum(import.meta.url, {
+    name: "CombatTechniqueIdentifier",
+    values: () => ({
+        CloseCombatTechnique: EnumCase({ type: CloseCombatTechniqueIdentifier() }),
+        RangedCombatTechnique: EnumCase({ type: RangedCombatTechniqueIdentifier() }),
+    }),
+});
+export const ExtensionRuleIdentifier = Enum(import.meta.url, {
+    name: "ExtensionRuleIdentifier",
+    values: () => ({
+        FocusRule: EnumCase({ type: FocusRuleIdentifier() }),
+        OptionalRule: EnumCase({ type: OptionalRuleIdentifier() }),
+    }),
+});
+export const SkillWithEnhancementsIdentifier = Enum(import.meta.url, {
+    name: "SkillWithEnhancementsIdentifier",
+    values: () => ({
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+    }),
+});
+export const SpellworkIdentifier = Enum(import.meta.url, {
+    name: "SpellworkIdentifier",
+    values: () => ({
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+    }),
+});
+export const LiturgyIdentifier = Enum(import.meta.url, {
+    name: "LiturgyIdentifier",
+    values: () => ({
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+    }),
+});
+export const MagicalActionIdentifier = Enum(import.meta.url, {
+    name: "MagicalActionIdentifier",
+    values: () => ({
+        Curse: EnumCase({ type: CurseIdentifier() }),
+        ElvenMagicalSong: EnumCase({ type: ElvenMagicalSongIdentifier() }),
+        DominationRitual: EnumCase({ type: DominationRitualIdentifier() }),
+        MagicalMelody: EnumCase({ type: MagicalMelodyIdentifier() }),
+        MagicalDance: EnumCase({ type: MagicalDanceIdentifier() }),
+        JesterTrick: EnumCase({ type: JesterTrickIdentifier() }),
+        AnimistPower: EnumCase({ type: AnimistPowerIdentifier() }),
+        GeodeRitual: EnumCase({ type: GeodeRitualIdentifier() }),
+        ZibiljaRitual: EnumCase({ type: ZibiljaRitualIdentifier() }),
+        MagicalRune: EnumCase({ type: MagicalRuneIdentifier() }),
+    }),
+});
+export const SelectOptionIdentifier = Enum(import.meta.url, {
+    name: "SelectOptionIdentifier",
+    values: () => ({
+        General: EnumCase({ type: GeneralIdentifier() }),
+        Blessing: EnumCase({ type: BlessingIdentifier() }),
+        Cantrip: EnumCase({ type: CantripIdentifier() }),
+        TradeSecret: EnumCase({ type: TradeSecretIdentifier() }),
+        Script: EnumCase({ type: ScriptIdentifier() }),
+        AnimalShape: EnumCase({ type: AnimalShapeIdentifier() }),
+        ArcaneBardTradition: EnumCase({ type: ArcaneBardTraditionIdentifier() }),
+        ArcaneDancerTradition: EnumCase({ type: ArcaneDancerTraditionIdentifier() }),
+        SexPractice: EnumCase({ type: SexPracticeIdentifier() }),
+        Race: EnumCase({ type: RaceIdentifier() }),
+        Culture: EnumCase({ type: CultureIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+        Element: EnumCase({ type: ElementIdentifier() }),
+        Property: EnumCase({ type: PropertyIdentifier() }),
+        Aspect: EnumCase({ type: AspectIdentifier() }),
+        Disease: EnumCase({ type: DiseaseIdentifier() }),
+        Poison: EnumCase({ type: PoisonIdentifier() }),
+        Language: EnumCase({ type: LanguageIdentifier() }),
+        Skill: EnumCase({ type: SkillIdentifier() }),
+        SkillApplication: EnumCase({ type: SkillApplicationIdentifier() }),
+        CloseCombatTechnique: EnumCase({ type: CloseCombatTechniqueIdentifier() }),
+        RangedCombatTechnique: EnumCase({ type: RangedCombatTechniqueIdentifier() }),
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+        TargetCategory: EnumCase({ type: TargetCategoryIdentifier() }),
+        Patron: EnumCase({ type: PatronIdentifier() }),
+    }),
+});
+export const RequirableSelectOptionIdentifier = Enum(import.meta.url, {
+    name: "RequirableSelectOptionIdentifier",
+    values: () => ({
+        General: EnumCase({ type: GeneralIdentifier() }),
+        Skill: EnumCase({ type: SkillIdentifier() }),
+        CloseCombatTechnique: EnumCase({ type: CloseCombatTechniqueIdentifier() }),
+        RangedCombatTechnique: EnumCase({ type: RangedCombatTechniqueIdentifier() }),
+        Property: EnumCase({ type: PropertyIdentifier() }),
+        Aspect: EnumCase({ type: AspectIdentifier() }),
+        Language: EnumCase({ type: LanguageIdentifier() }),
+        AnimalShape: EnumCase({ type: AnimalShapeIdentifier() }),
+        LiturgicalChant: EnumCase({ type: LiturgicalChantIdentifier() }),
+        Ceremony: EnumCase({ type: CeremonyIdentifier() }),
+        Spell: EnumCase({ type: SpellIdentifier() }),
+        Ritual: EnumCase({ type: RitualIdentifier() }),
+        TradeSecret: EnumCase({ type: TradeSecretIdentifier() }),
+    }),
+});
+export const CoreRuleDerivableContentIdentifier = Enum(import.meta.url, {
+    name: "CoreRuleDerivableContentIdentifier",
+    values: () => ({
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        FamiliarSpecialAbility: EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
+        MagicalSpecialAbility: EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+    }),
+});
+export const EquipmentIdentifier = Enum(import.meta.url, {
+    name: "EquipmentIdentifier",
+    values: () => ({
+        Ammunition: EnumCase({ type: AmmunitionIdentifier() }),
+        Animal: EnumCase({ type: AnimalIdentifier() }),
+        AnimalCare: EnumCase({ type: AnimalCareIdentifier() }),
+        Armor: EnumCase({ type: ArmorIdentifier() }),
+        BandageOrRemedy: EnumCase({ type: BandageOrRemedyIdentifier() }),
+        Book: EnumCase({ type: BookIdentifier() }),
+        CeremonialItem: EnumCase({ type: CeremonialItemIdentifier() }),
+        Clothes: EnumCase({ type: ClothesIdentifier() }),
+        Container: EnumCase({ type: ContainerIdentifier() }),
+        Elixir: EnumCase({ type: ElixirIdentifier() }),
+        EquipmentOfBlessedOnes: EnumCase({ type: EquipmentOfBlessedOnesIdentifier() }),
+        GemOrPreciousStone: EnumCase({ type: GemOrPreciousStoneIdentifier() }),
+        IlluminationLightSource: EnumCase({ type: IlluminationLightSourceIdentifier() }),
+        IlluminationRefillsOrSupplies: EnumCase({ type: IlluminationRefillsOrSuppliesIdentifier() }),
+        Jewelry: EnumCase({ type: JewelryIdentifier() }),
+        Liebesspielzeug: EnumCase({ type: LiebesspielzeugIdentifier() }),
+        LuxuryGood: EnumCase({ type: LuxuryGoodIdentifier() }),
+        MagicalArtifact: EnumCase({ type: MagicalArtifactIdentifier() }),
+        MusicalInstrument: EnumCase({ type: MusicalInstrumentIdentifier() }),
+        OrienteeringAid: EnumCase({ type: OrienteeringAidIdentifier() }),
+        Poison: EnumCase({ type: PoisonIdentifier() }),
+        RopeOrChain: EnumCase({ type: RopeOrChainIdentifier() }),
+        Stationary: EnumCase({ type: StationeryIdentifier() }),
+        ThievesTool: EnumCase({ type: ThievesToolIdentifier() }),
+        ToolOfTheTrade: EnumCase({ type: ToolOfTheTradeIdentifier() }),
+        TravelGearOrTool: EnumCase({ type: TravelGearOrToolIdentifier() }),
+        Vehicle: EnumCase({ type: VehicleIdentifier() }),
+        Weapon: EnumCase({ type: WeaponIdentifier() }),
+        WeaponAccessory: EnumCase({ type: WeaponAccessoryIdentifier() }),
+    }),
+});

package/lib/types/_ImprovementCost.d.ts

@@ -1,4 +1,7 @@
-/**
- * @title Improvement Cost
- */
-export type ImprovementCost = "A" | "B" | "C" | "D";
+import { Enum, EnumCase } from "tsondb/schema/def";
+export declare const ImprovementCost: Enum<"ImprovementCost", {
+    A: EnumCase<null>;
+    B: EnumCase<null>;
+    C: EnumCase<null>;
+    D: EnumCase<null>;
+}, []>;

package/lib/types/_ImprovementCost.js

@@ -1 +1,10 @@
-export {};
+import { Enum, EnumCase } from "tsondb/schema/def";
+export const ImprovementCost = Enum(import.meta.url, {
+    name: "ImprovementCost",
+    values: () => ({
+        A: EnumCase({ type: null }),
+        B: EnumCase({ type: null }),
+        C: EnumCase({ type: null }),
+        D: EnumCase({ type: null }),
+    }),
+});

package/lib/types/_Influence.d.ts

@@ -1,49 +1,78 @@
-/**
- * @main Influence
- */
-import { Errata } from "./source/_Erratum.js";
-import { PublicationRefs } from "./source/_PublicationRef.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyString } from "./_NonEmptyString.js";
-import { InfluencePrerequisites } from "./_Prerequisite.js";
-/**
- * @title Influence
- */
-export type Influence = {
-    /**
-     * The influence's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    prerequisites: InfluencePrerequisites;
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<InfluenceTranslation>;
-};
-export type InfluenceTranslation = {
-    /**
-     * The influence name.
-     */
-    name: NonEmptyString;
-    /**
-     * The effects of the influence. They should be sorted like they are in
-     * the book.
-     * @minItems 1
-     */
-    effects: InfluenceEffect[];
-    errata?: Errata;
-};
-export type InfluenceEffect = {
-    /**
-     * An optional label that is displayed and placed before the actual
-     * text.
-     */
-    label?: NonEmptyString;
-    /**
-     * The effect text.
-     */
-    text: NonEmptyString;
-};
+import { Array, Entity, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const Influence: Entity<"Influence", {
+    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InfluencePrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"PrerequisitesElement", {
+        Single: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+        Disjunction: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
+            list: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+                Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
+                ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+                    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                        Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    }, []>>, false>;
+                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                        replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+        Group: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", Object<{
+            list: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, true>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
+                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"InfluenceTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        effects: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"InfluenceEffect", Object<{
+            label: import("tsondb/schema/def").MemberDecl<String, false>;
+            text: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, false>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/_Influence.js

@@ -1,4 +1,42 @@
-/**
- * @main Influence
- */
-export {};
+import { Array, Entity, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { InfluencePrerequisites } from "./_Prerequisite.js";
+import { NestedLocaleMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Influence = Entity(import.meta.url, {
+    name: "Influence",
+    namePlural: "Influences",
+    type: () => Object({
+        prerequisites: Optional({
+            type: IncludeIdentifier(InfluencePrerequisites),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "InfluenceTranslation", Object({
+            name: Required({
+                comment: "The influence’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            effects: Optional({
+                comment: "The effects of the influence. They should be sorted like they are in the book.",
+                type: Array(IncludeIdentifier(InfluenceEffect), { minItems: 1 }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const InfluenceEffect = TypeAlias(import.meta.url, {
+    name: "InfluenceEffect",
+    type: () => Object({
+        label: Optional({
+            comment: "An optional label that is displayed and placed before the actual text.",
+            type: String({ minLength: 1 }),
+        }),
+        text: Required({
+            comment: "The effect text.",
+            type: String({ minLength: 1 }),
+        }),
+    }),
+});