@optolith/database-schema 0.42.1

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -0,0 +1,180 @@
+import * as DB from "tsondb/schema/dsl";
+import { ActivatablePrerequisite } from "./single/ActivatablePrerequisite.js";
+import { AncestorBloodPrerequisite } from "./single/AncestorBloodPrerequisite.js";
+import { AnimistPowerPrerequisite } from "./single/AnimistPowerPrerequisite.js";
+import { CulturePrerequisite } from "./single/CulturePrerequisite.js";
+import { EnhancementPrerequisite } from "./single/EnhancementPrerequisite.js";
+import { InfluencePrerequisite } from "./single/InfluencePrerequisite.js";
+import { PactPrerequisite } from "./single/PactPrerequisite.js";
+import { PersonalityTraitPrerequisite } from "./single/PersonalityTraitPrerequisite.js";
+import { PrimaryAttributePrerequisite } from "./single/PrimaryAttributePrerequisite.js";
+import { ProfessionPrerequisite } from "./single/ProfessionPrerequisite.js";
+import { PublicationPrerequisite } from "./single/PublicationPrerequisite.js";
+import { RacePrerequisite } from "./single/RacePrerequisite.js";
+import { RatedMinimumNumberPrerequisite } from "./single/RatedMinimumNumberPrerequisite.js";
+import { RatedPrerequisite } from "./single/RatedPrerequisite.js";
+import { RatedSumPrerequisite } from "./single/RatedSumPrerequisite.js";
+import { RulePrerequisite } from "./single/RulePrerequisite.js";
+import { SexPrerequisite } from "./single/SexPrerequisite.js";
+import { SexualCharacteristicPrerequisite } from "./single/SexualCharacteristicPrerequisite.js";
+import { SocialStatusPrerequisite } from "./single/SocialStatusPrerequisite.js";
+import { StatePrerequisite } from "./single/StatePrerequisite.js";
+import { TextPrerequisite } from "./single/TextPrerequisite.js";
+import { BlessedTraditionPrerequisite, MagicalTraditionPrerequisite, } from "./single/TraditionPrerequisite.js";
+export const RulePrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "RulePrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+    }),
+});
+export const DerivedCharacteristicPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicPrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+        BlessedTradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionPrerequisite) }),
+        MagicalTradition: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalTraditionPrerequisite) }),
+    }),
+});
+export const DerivedCharacteristicModifierPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicModifierPrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+    }),
+});
+export const PublicationPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "PublicationPrerequisiteGroup",
+    values: () => ({
+        Publication: DB.EnumCase({ type: DB.IncludeIdentifier(PublicationPrerequisite) }),
+    }),
+});
+export const GeneralPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "GeneralPrerequisiteGroup",
+    values: () => ({
+        Sex: DB.EnumCase({ type: DB.IncludeIdentifier(SexPrerequisite) }),
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+        Pact: DB.EnumCase({ type: DB.IncludeIdentifier(PactPrerequisite) }),
+        SocialStatus: DB.EnumCase({ type: DB.IncludeIdentifier(SocialStatusPrerequisite) }),
+        State: DB.EnumCase({ type: DB.IncludeIdentifier(StatePrerequisite) }),
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+        PrimaryAttribute: DB.EnumCase({ type: DB.IncludeIdentifier(PrimaryAttributePrerequisite) }),
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+        BlessedTradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionPrerequisite) }),
+        MagicalTradition: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalTraditionPrerequisite) }),
+        Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
+        RatedMinimumNumber: DB.EnumCase({ type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisite) }),
+        RatedSum: DB.EnumCase({ type: DB.IncludeIdentifier(RatedSumPrerequisite) }),
+        Enhancement: DB.EnumCase({ type: DB.IncludeIdentifier(EnhancementPrerequisite) }),
+        Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextPrerequisite) }),
+        SexualCharacteristic: DB.EnumCase({
+            type: DB.IncludeIdentifier(SexualCharacteristicPrerequisite),
+        }),
+    }),
+});
+export const ProfessionPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "ProfessionPrerequisiteGroup",
+    values: () => ({
+        Sex: DB.EnumCase({ type: DB.IncludeIdentifier(SexPrerequisite) }),
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+        Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
+    }),
+});
+export const AdvantageDisadvantagePrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "AdvantageDisadvantagePrerequisiteGroup",
+    values: () => {
+        return {
+            CommonSuggestedByRCP: DB.EnumCase({ type: null }),
+            NoOtherAncestorBloodAdvantage: DB.EnumCase({
+                type: AncestorBloodPrerequisite,
+            }),
+            ...GeneralPrerequisiteGroup.type.value.values,
+        };
+    },
+});
+export const ArcaneTraditionPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "ArcaneTraditionPrerequisiteGroup",
+    values: () => ({
+        Sex: DB.EnumCase({ type: DB.IncludeIdentifier(SexPrerequisite) }),
+        Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+    }),
+});
+export const PersonalityTraitPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "PersonalityTraitPrerequisiteGroup",
+    values: () => ({
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+        PersonalityTrait: DB.EnumCase({ type: DB.IncludeIdentifier(PersonalityTraitPrerequisite) }),
+        Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const SpellworkPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "SpellworkPrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+        Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
+    }),
+});
+export const LiturgyPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "LiturgyPrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+    }),
+});
+export const InfluencePrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "InfluencePrerequisiteGroup",
+    values: () => ({
+        Influence: DB.EnumCase({ type: DB.IncludeIdentifier(InfluencePrerequisite) }),
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Profession: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionPrerequisite) }),
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+        Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const LanguagePrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "LanguagePrerequisiteGroup",
+    values: () => ({
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+        Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const AnimistPowerPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "AnimistPowerPrerequisiteGroup",
+    values: () => ({
+        AnimistPower: DB.EnumCase({ type: DB.IncludeIdentifier(AnimistPowerPrerequisite) }),
+    }),
+});
+export const TribePrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "TribePrerequisiteGroup",
+    values: () => ({
+        Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
+        Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+    }),
+});
+export const GeodeRitualPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "GeodeRitualPrerequisiteGroup",
+    values: () => ({
+        Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
+        Influence: DB.EnumCase({ type: DB.IncludeIdentifier(InfluencePrerequisite) }),
+    }),
+});
+export const EnhancementPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "EnhancementPrerequisiteGroup",
+    values: () => ({
+        Enhancement: DB.EnumCase({ type: DB.IncludeIdentifier(EnhancementPrerequisite) }),
+        Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
+    }),
+});
+export const PreconditionGroup = DB.Enum(import.meta.url, {
+    name: "PreconditionGroup",
+    values: () => ({
+        Publication: DB.EnumCase({ type: DB.IncludeIdentifier(PublicationPrerequisite) }),
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+        SexualCharacteristic: DB.EnumCase({
+            type: DB.IncludeIdentifier(SexualCharacteristicPrerequisite),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/ActivatablePrerequisite.d.ts

@@ -0,0 +1,133 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ActivatablePrerequisite: DB.TypeAlias<"ActivatablePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    active: DB.MemberDecl<DB.Boolean, true>;
+    level: DB.MemberDecl<DB.Integer, false>;
+    options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        General: DB.EnumCase<DB.ReferenceIdentifier>;
+        Race: DB.EnumCase<DB.ReferenceIdentifier>;
+        Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+        CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+        RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+        Property: DB.EnumCase<DB.ReferenceIdentifier>;
+        Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+        Language: DB.EnumCase<DB.ReferenceIdentifier>;
+        AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+        TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        Element: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>>, false>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    when: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Preconditions", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"PreconditionGroup", {
+        Publication: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, []>>>;
+        Rule: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisite", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+                FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                OptionalRule: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, []>>>;
+        SexualCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexualCharacteristicPrerequisite", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SexualCharacteristic", {
+                Penis: DB.EnumCase<null>;
+                Vagina: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+    }, []>>>, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/ActivatablePrerequisite.js

@@ -0,0 +1,32 @@
+import * as DB from "tsondb/schema/dsl";
+import { ActivatableIdentifier, RequirableSelectOptionIdentifier } from "../../_IdentifierGroup.js";
+import { Preconditions } from "../ConditionalPrerequisites.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const ActivatablePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "ActivatablePrerequisite",
+    comment: "Requires a specific advantage, disadvantage or special ability.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The activatable entry’s identifier.",
+            type: DB.IncludeIdentifier(ActivatableIdentifier),
+        }),
+        active: DB.Required({
+            comment: "If the required entry should be required to be active or inactive.",
+            type: DB.Boolean(),
+        }),
+        level: DB.Optional({
+            comment: "The required minimum level of the entry.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        options: DB.Optional({
+            comment: "Required select options. Order is important. Typically, you only need the first array index, though.",
+            type: DB.Array(DB.IncludeIdentifier(RequirableSelectOptionIdentifier), { minItems: 1 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+        when: DB.Optional({
+            type: DB.IncludeIdentifier(Preconditions),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/AncestorBloodPrerequisite.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Requires that no other Ancestor Blood advantage is active.
+ */
+export declare const AncestorBloodPrerequisite: null;

package/lib/types/prerequisites/single/AncestorBloodPrerequisite.js

@@ -0,0 +1,4 @@
+/**
+ * Requires that no other Ancestor Blood advantage is active.
+ */
+export const AncestorBloodPrerequisite = null;

package/lib/types/prerequisites/single/AnimistPowerPrerequisite.d.ts

@@ -0,0 +1,18 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AnimistPowerPrerequisite: DB.TypeAlias<"AnimistPowerPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    level: DB.MemberDecl<DB.Integer, false>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/AnimistPowerPrerequisite.js

@@ -0,0 +1,24 @@
+import * as DB from "tsondb/schema/dsl";
+import { AnimistPowerIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const AnimistPowerPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "AnimistPowerPrerequisite",
+    comment: "Requires a specific animist power to be on a minimum value.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The animist power’s identifier.",
+            type: AnimistPowerIdentifier(),
+        }),
+        level: DB.Optional({
+            comment: "The level to which the minimum value applies.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        value: DB.Required({
+            comment: "The required minimum value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/CulturePrerequisite.d.ts

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CulturePrerequisite: DB.TypeAlias<"CulturePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/CulturePrerequisite.js

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+import { CultureIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const CulturePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "CulturePrerequisite",
+    comment: "Requires a specific culture or one of a specific set of cultures.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The culture’s identifier.",
+            type: CultureIdentifier(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/EnhancementPrerequisite.d.ts

@@ -0,0 +1,4 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const EnhancementPrerequisite: DB.TypeAlias<"EnhancementPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+}>, []>;

package/lib/types/prerequisites/single/EnhancementPrerequisite.js

@@ -0,0 +1,12 @@
+import * as DB from "tsondb/schema/dsl";
+import { EnhancementIdentifier } from "../../_Identifier.js";
+export const EnhancementPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "EnhancementPrerequisite",
+    comment: "Requires a specific enhancement from a skill.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The required enhancement.",
+            type: EnhancementIdentifier(),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/InfluencePrerequisite.d.ts

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const InfluencePrerequisite: DB.TypeAlias<"InfluencePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    active: DB.MemberDecl<DB.Boolean, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/InfluencePrerequisite.js

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { InfluenceIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const InfluencePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "InfluencePrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The influence’s identifier.",
+            type: InfluenceIdentifier(),
+        }),
+        active: DB.Required({
+            comment: "If the referenced influence must or must not be chosen.",
+            type: DB.Boolean(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/PactPrerequisite.d.ts

@@ -0,0 +1,18 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PactPrerequisite: DB.TypeAlias<"PactPrerequisite", DB.Object<{
+    category: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    domain: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    level: DB.MemberDecl<DB.Integer, false>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/PactPrerequisite.js

@@ -0,0 +1,24 @@
+import * as DB from "tsondb/schema/dsl";
+import { PactCategoryIdentifier, PactDomainIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const PactPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "PactPrerequisite",
+    comment: "Requires a specific pact.",
+    type: () => DB.Object({
+        category: DB.Required({
+            comment: "The required pact category.",
+            type: PactCategoryIdentifier(),
+        }),
+        domain: DB.Optional({
+            comment: "The required domain(s).",
+            type: DB.Array(PactDomainIdentifier(), { minItems: 1 }),
+        }),
+        level: DB.Optional({
+            comment: "The level to which the minimum value applies.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/PersonalityTraitPrerequisite.d.ts

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PersonalityTraitPrerequisite: DB.TypeAlias<"PersonalityTraitPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    active: DB.MemberDecl<DB.Boolean, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/PersonalityTraitPrerequisite.js

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { PersonalityTraitIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const PersonalityTraitPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "PersonalityTraitPrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The personality trait’s identifier.",
+            type: PersonalityTraitIdentifier(),
+        }),
+        active: DB.Required({
+            comment: "If checked, the prerequisite **must** be present. If not checked, prerequisite **must not** be present.",
+            type: DB.Boolean(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/PrimaryAttributePrerequisite.d.ts

@@ -0,0 +1,20 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PrimaryAttributePrerequisite: DB.TypeAlias<"PrimaryAttributePrerequisite", DB.Object<{
+    category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PrimaryAttributeCategory", {
+        Blessed: DB.EnumCase<null>;
+        Magical: DB.EnumCase<null>;
+    }, []>>, true>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/PrimaryAttributePrerequisite.js

@@ -0,0 +1,25 @@
+import * as DB from "tsondb/schema/dsl";
+import { DisplayOption } from "../DisplayOption.js";
+export const PrimaryAttributePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "PrimaryAttributePrerequisite",
+    type: () => DB.Object({
+        category: DB.Required({
+            comment: "Is the required primary attribute for spellcasters or blessed ones?",
+            type: DB.IncludeIdentifier(PrimaryAttributeCategory),
+        }),
+        value: DB.Required({
+            comment: "Required value of the attribute.",
+            type: DB.Integer({ minimum: 9 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const PrimaryAttributeCategory = DB.Enum(import.meta.url, {
+    name: "PrimaryAttributeCategory",
+    values: () => ({
+        Blessed: DB.EnumCase({ type: null }),
+        Magical: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/prerequisites/single/ProfessionPrerequisite.d.ts

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ProfessionPrerequisite: DB.TypeAlias<"ProfessionPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    displayOption: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;