optolith-database-schema 0.17.0 → 0.18.1

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -1 +1,160 @@
-export {};
+import { Enum, EnumCase, IncludeIdentifier } from "tsondb/schema/def";
+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 { PrimaryAttributePrerequisite } from "./single/PrimaryAttributePrerequisite.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 DerivedCharacteristicPrerequisiteGroup = Enum(import.meta.url, {
+    name: "DerivedCharacteristicPrerequisiteGroup",
+    values: () => ({
+        Rule: EnumCase({ type: IncludeIdentifier(RulePrerequisite) }),
+    }),
+});
+export const PublicationPrerequisiteGroup = Enum(import.meta.url, {
+    name: "PublicationPrerequisiteGroup",
+    values: () => ({
+        Publication: EnumCase({ type: IncludeIdentifier(PublicationPrerequisite) }),
+    }),
+});
+export const GeneralPrerequisiteGroup = Enum(import.meta.url, {
+    name: "GeneralPrerequisiteGroup",
+    values: () => ({
+        Sex: EnumCase({ type: IncludeIdentifier(SexPrerequisite) }),
+        Race: EnumCase({ type: IncludeIdentifier(RacePrerequisite) }),
+        Culture: EnumCase({ type: IncludeIdentifier(CulturePrerequisite) }),
+        Pact: EnumCase({ type: IncludeIdentifier(PactPrerequisite) }),
+        SocialStatus: EnumCase({ type: IncludeIdentifier(SocialStatusPrerequisite) }),
+        State: EnumCase({ type: IncludeIdentifier(StatePrerequisite) }),
+        Rule: EnumCase({ type: IncludeIdentifier(RulePrerequisite) }),
+        PrimaryAttribute: EnumCase({ type: IncludeIdentifier(PrimaryAttributePrerequisite) }),
+        Activatable: EnumCase({ type: IncludeIdentifier(ActivatablePrerequisite) }),
+        BlessedTradition: EnumCase({ type: IncludeIdentifier(BlessedTraditionPrerequisite) }),
+        MagicalTradition: EnumCase({ type: IncludeIdentifier(MagicalTraditionPrerequisite) }),
+        Rated: EnumCase({ type: IncludeIdentifier(RatedPrerequisite) }),
+        RatedMinimumNumber: EnumCase({ type: IncludeIdentifier(RatedMinimumNumberPrerequisite) }),
+        RatedSum: EnumCase({ type: IncludeIdentifier(RatedSumPrerequisite) }),
+        Enhancement: EnumCase({ type: IncludeIdentifier(EnhancementPrerequisite) }),
+        Text: EnumCase({ type: IncludeIdentifier(TextPrerequisite) }),
+        SexualCharacteristic: EnumCase({ type: IncludeIdentifier(SexualCharacteristicPrerequisite) }),
+    }),
+});
+export const ProfessionPrerequisiteGroup = Enum(import.meta.url, {
+    name: "ProfessionPrerequisiteGroup",
+    values: () => ({
+        Sex: EnumCase({ type: IncludeIdentifier(SexPrerequisite) }),
+        Race: EnumCase({ type: IncludeIdentifier(RacePrerequisite) }),
+        Culture: EnumCase({ type: IncludeIdentifier(CulturePrerequisite) }),
+        Activatable: EnumCase({ type: IncludeIdentifier(ActivatablePrerequisite) }),
+        Rated: EnumCase({ type: IncludeIdentifier(RatedPrerequisite) }),
+    }),
+});
+export const AdvantageDisadvantagePrerequisiteGroup = Enum(import.meta.url, {
+    name: "AdvantageDisadvantagePrerequisiteGroup",
+    values: () => {
+        return {
+            CommonSuggestedByRCP: EnumCase({ type: null }),
+            Sex: EnumCase({ type: IncludeIdentifier(SexPrerequisite) }),
+            Race: EnumCase({ type: IncludeIdentifier(RacePrerequisite) }),
+            Culture: EnumCase({ type: IncludeIdentifier(CulturePrerequisite) }),
+            Pact: EnumCase({ type: IncludeIdentifier(PactPrerequisite) }),
+            SocialStatus: EnumCase({ type: IncludeIdentifier(SocialStatusPrerequisite) }),
+            State: EnumCase({ type: IncludeIdentifier(StatePrerequisite) }),
+            Rule: EnumCase({ type: IncludeIdentifier(RulePrerequisite) }),
+            PrimaryAttribute: EnumCase({ type: IncludeIdentifier(PrimaryAttributePrerequisite) }),
+            Activatable: EnumCase({ type: IncludeIdentifier(ActivatablePrerequisite) }),
+            BlessedTradition: EnumCase({ type: IncludeIdentifier(BlessedTraditionPrerequisite) }),
+            MagicalTradition: EnumCase({ type: IncludeIdentifier(MagicalTraditionPrerequisite) }),
+            Rated: EnumCase({ type: IncludeIdentifier(RatedPrerequisite) }),
+            RatedMinimumNumber: EnumCase({ type: IncludeIdentifier(RatedMinimumNumberPrerequisite) }),
+            RatedSum: EnumCase({ type: IncludeIdentifier(RatedSumPrerequisite) }),
+            Enhancement: EnumCase({ type: IncludeIdentifier(EnhancementPrerequisite) }),
+            Text: EnumCase({ type: IncludeIdentifier(TextPrerequisite) }),
+            NoOtherAncestorBloodAdvantage: EnumCase({
+                type: AncestorBloodPrerequisite,
+            }),
+            SexualCharacteristic: EnumCase({ type: IncludeIdentifier(SexualCharacteristicPrerequisite) }),
+        };
+    },
+});
+export const ArcaneTraditionPrerequisiteGroup = Enum(import.meta.url, {
+    name: "ArcaneTraditionPrerequisiteGroup",
+    values: () => ({
+        Sex: EnumCase({ type: IncludeIdentifier(SexPrerequisite) }),
+        Culture: EnumCase({ type: IncludeIdentifier(CulturePrerequisite) }),
+    }),
+});
+export const PersonalityTraitPrerequisiteGroup = Enum(import.meta.url, {
+    name: "PersonalityTraitPrerequisiteGroup",
+    values: () => ({
+        Culture: EnumCase({ type: IncludeIdentifier(CulturePrerequisite) }),
+        Text: EnumCase({ type: IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const SpellworkPrerequisiteGroup = Enum(import.meta.url, {
+    name: "SpellworkPrerequisiteGroup",
+    values: () => ({
+        Rule: EnumCase({ type: IncludeIdentifier(RulePrerequisite) }),
+        Rated: EnumCase({ type: IncludeIdentifier(RatedPrerequisite) }),
+    }),
+});
+export const LiturgyPrerequisiteGroup = Enum(import.meta.url, {
+    name: "LiturgyPrerequisiteGroup",
+    values: () => ({
+        Rule: EnumCase({ type: IncludeIdentifier(RulePrerequisite) }),
+    }),
+});
+export const InfluencePrerequisiteGroup = Enum(import.meta.url, {
+    name: "InfluencePrerequisiteGroup",
+    values: () => ({
+        Influence: EnumCase({ type: IncludeIdentifier(InfluencePrerequisite) }),
+        Text: EnumCase({ type: IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const LanguagePrerequisiteGroup = Enum(import.meta.url, {
+    name: "LanguagePrerequisiteGroup",
+    values: () => ({
+        Race: EnumCase({ type: IncludeIdentifier(RacePrerequisite) }),
+        Activatable: EnumCase({ type: IncludeIdentifier(ActivatablePrerequisite) }),
+        Text: EnumCase({ type: IncludeIdentifier(TextPrerequisite) }),
+    }),
+});
+export const AnimistPowerPrerequisiteGroup = Enum(import.meta.url, {
+    name: "AnimistPowerPrerequisiteGroup",
+    values: () => ({
+        AnimistPower: EnumCase({ type: IncludeIdentifier(AnimistPowerPrerequisite) }),
+    }),
+});
+export const GeodeRitualPrerequisiteGroup = Enum(import.meta.url, {
+    name: "GeodeRitualPrerequisiteGroup",
+    values: () => ({
+        Influence: EnumCase({ type: IncludeIdentifier(InfluencePrerequisite) }),
+    }),
+});
+export const EnhancementPrerequisiteGroup = Enum(import.meta.url, {
+    name: "EnhancementPrerequisiteGroup",
+    values: () => ({
+        Enhancement: EnumCase({ type: IncludeIdentifier(EnhancementPrerequisite) }),
+    }),
+});
+export const PreconditionGroup = Enum(import.meta.url, {
+    name: "PreconditionGroup",
+    values: () => ({
+        Publication: EnumCase({ type: IncludeIdentifier(PublicationPrerequisite) }),
+        SexualCharacteristic: EnumCase({ type: IncludeIdentifier(SexualCharacteristicPrerequisite) }),
+    }),
+});

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

@@ -1,31 +1,107 @@
-import { ActivatableIdentifier, RequirableSelectOptionIdentifier } from "../../_IdentifierGroup.js";
-import { Preconditions } from "../ConditionalPrerequisites.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific advantage, disadvantage or special ability.
- * @title Activatable Prerequisite
- */
-export type ActivatablePrerequisite = {
-    /**
-     * The activatable entry's identifier.
-     */
-    id: ActivatableIdentifier;
-    /**
-     * If the required entry should be required to be active or inactive.
-     */
-    active: boolean;
-    /**
-     * The required minimum level of the entry.
-     * @integer
-     * @minimum 1
-     */
-    level?: number;
-    /**
-     * Required select options. Order is important. Typically, you only need the
-     * first array index, though.
-     * @minItems 1
-     */
-    options?: RequirableSelectOptionIdentifier[];
-    display_option?: DisplayOption;
-    when?: Preconditions;
-};
+import { Array, Boolean, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const ActivatablePrerequisite: TypeAlias<"ActivatablePrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ActivatableIdentifier", {
+        Advantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AncestorGlyph: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ArcaneOrbEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AttireEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BowlEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BrawlingSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CauldronEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ChronicleEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CommandSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        DaggerRitual: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FamiliarSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FoolsHatEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        InstrumentEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        KarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Krallenkettenzauber: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LycantropicGift: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSign: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        OrbEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        PactGift: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ProtectiveWardingCircleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        RingEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Sermon: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SickleRitual: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SikaryanDrainSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SkillStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SpellSwordEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        StaffEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ToyEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Trinkhornzauber: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        VampiricGift: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Vision: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        WandEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        WeaponEnchantment: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    active: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    level: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    options: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"RequirableSelectOptionIdentifier", {
+        General: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Skill: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CloseCombatTechnique: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        RangedCombatTechnique: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Property: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Aspect: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Language: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AnimalShape: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalChant: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Ceremony: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Spell: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Ritual: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        TradeSecret: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>>, false>;
+    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<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    when: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Preconditions", Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"PreconditionGroup", {
+        Publication: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"PublicationPrerequisite", Object<{
+            id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, 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<import("tsondb/schema/def").StringType, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, []>>>;
+        SexualCharacteristic: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"SexualCharacteristicPrerequisite", Object<{
+            id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SexualCharacteristic", {
+                Penis: import("tsondb/schema/def").EnumCaseDecl<null>;
+                Vagina: import("tsondb/schema/def").EnumCaseDecl<null>;
+            }, []>>, true>;
+        }>, []>>>;
+    }, []>>>, []>>, false>;
+}>, []>;

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

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

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

@@ -1,5 +1,4 @@
 /**
  * Requires that no other Ancestor Blood advantage is active.
- * @title Ancestor Blood Prerequisite
  */
-export type AncestorBloodPrerequisite = {};
+export declare const AncestorBloodPrerequisite: null;

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

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

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

@@ -1,26 +1,18 @@
-import { AnimistPowerIdentifier } from "../../_Identifier.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific animist power to be on a minimum value.
- * @title Animist Power Prerequisite
- */
-export type AnimistPowerPrerequisite = {
-    /**
-     * The animist power's identifier.
-     */
-    id: AnimistPowerIdentifier;
-    /**
-     * The level to which the minimum value applies.
-     * @integer
-     * @minimum 2
-     * @default 1
-     */
-    level?: number;
-    /**
-     * The required minimum value.
-     * @integer
-     * @minimum 0
-     */
-    value: number;
-    display_option?: DisplayOption;
-};
+import { IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const AnimistPowerPrerequisite: TypeAlias<"AnimistPowerPrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    level: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    value: import("tsondb/schema/def").MemberDecl<Integer, 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<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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

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

@@ -1,13 +1,16 @@
-import { CultureIdentifier } from "../../_Identifier.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific culture or one of a specific set of cultures.
- * @title Culture Prerequisite
- */
-export type CulturePrerequisite = {
-    /**
-     * The culture's identifier.
-     */
-    id: CultureIdentifier;
-    display_option?: DisplayOption;
-};
+import { IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const CulturePrerequisite: TypeAlias<"CulturePrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, 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<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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

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

@@ -1,39 +1,4 @@
-import { SkillWithEnhancementsIdentifier } from "../../_IdentifierGroup.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific enhancement from a skill. This should **not** be used
- * for enhancements themselves; they can only require enhancements from the same
- * skill they enhance.
- * @title External Enhancement Prerequisite
- */
-export type ExternalEnhancementPrerequisite = {
-    /**
-     * The required skill.
-     */
-    skill: SkillWithEnhancementsReference;
-    /**
-     * The required enhancement.
-     */
-    enhancement: EnhancementsReference;
-    display_option?: DisplayOption;
-};
-export type SkillWithEnhancementsReference = {
-    /**
-     * The skill's identifier.
-     */
-    id: SkillWithEnhancementsIdentifier;
-};
-export type EnhancementsReference = {
-    /**
-     * The enhancement's identifier.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-};
-/**
- * Requires a specific enhancement from a skill. This can only be used by an
- * enhancement to require another enhancement from the same skill.
- * @title Internal Enhancement Prerequisite
- */
-export type InternalEnhancementPrerequisite = EnhancementsReference;
+import { Object, TypeAlias } from "tsondb/schema/def";
+export declare const EnhancementPrerequisite: TypeAlias<"EnhancementPrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+}>, []>;

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

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

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

@@ -1,16 +1,17 @@
-import { InfluenceIdentifier } from "../../_Identifier.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * @title Influence Prerequisite
- */
-export type InfluencePrerequisite = {
-    /**
-     * The influence's identifier.
-     */
-    id: InfluenceIdentifier;
-    /**
-     * If the referenced influence must or must not be chosen.
-     */
-    active: boolean;
-    display_option?: DisplayOption;
-};
+import { Boolean, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const InfluencePrerequisite: TypeAlias<"InfluencePrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    active: import("tsondb/schema/def").MemberDecl<Boolean, 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<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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