optolith-database-schema 0.25.0 → 0.26.1

package/lib/types/_ActivatableSelectOptionCategory.js

@@ -16,6 +16,33 @@ export const SelectOptionCategory = Enum(import.meta.url, {
         Races: EnumCase({ type: null }),
         Cultures: EnumCase({ type: null }),
         RacesAndCultures: EnumCase({ type: null }),
+        HomunculusTypes: EnumCase({ type: null }),
+        BlessedTraditions: EnumCase({ type: IncludeIdentifier(BlessedTraditionsSelectOptionCategory) }),
+        Elements: EnumCase({ type: IncludeIdentifier(ElementsSelectOptionCategory) }),
+        Properties: EnumCase({ type: IncludeIdentifier(PropertiesSelectOptionCategory) }),
+        Aspects: EnumCase({ type: IncludeIdentifier(AspectSelectOptionCategory) }),
+        Diseases: EnumCase({ type: IncludeIdentifier(DiseasesPoisonsSelectOptionCategory) }),
+        Poisons: EnumCase({ type: IncludeIdentifier(DiseasesPoisonsSelectOptionCategory) }),
+        Languages: EnumCase({ type: IncludeIdentifier(LanguagesSelectOptionCategory) }),
+        Skills: EnumCase({ type: IncludeIdentifier(SkillsSelectOptionCategory) }),
+        CombatTechniques: EnumCase({ type: IncludeIdentifier(CombatTechniquesSelectOptionCategory) }),
+        TargetCategories: EnumCase({ type: IncludeIdentifier(TargetCategoriesSelectOptionCategory) }),
+    }),
+});
+export const TradeSecretSelectOptionCategory = Enum(import.meta.url, {
+    name: "TradeSecretSelectOptionCategory",
+    values: () => ({
+        Blessings: EnumCase({ type: null }),
+        Cantrips: EnumCase({ type: null }),
+        Scripts: EnumCase({ type: null }),
+        AnimalShapes: EnumCase({ type: null }),
+        ArcaneBardTraditions: EnumCase({ type: null }),
+        ArcaneDancerTraditions: EnumCase({ type: null }),
+        SexPractices: EnumCase({ type: null }),
+        Races: EnumCase({ type: null }),
+        Cultures: EnumCase({ type: null }),
+        RacesAndCultures: EnumCase({ type: null }),
+        HomunculusTypes: EnumCase({ type: null }),
         BlessedTraditions: EnumCase({ type: IncludeIdentifier(BlessedTraditionsSelectOptionCategory) }),
         Elements: EnumCase({ type: IncludeIdentifier(ElementsSelectOptionCategory) }),
         Properties: EnumCase({ type: IncludeIdentifier(PropertiesSelectOptionCategory) }),
@@ -189,6 +216,12 @@ const CombatTechniquesSelectOptionCategory = TypeAlias(import.meta.url, {
                 minItems: 1,
             }),
         }),
+        bindingCost: Optional({
+            comment: "Generate binding cost values for each entry.\n\n*Note: This only works if the entry it is defined on supports binding costs, i.e. is a tradition artifact enchantment.*",
+            type: GenIncludeIdentifier(SelectOptionsBindingCostValue, [
+                IncludeIdentifier(CombatTechniqueIdentifier),
+            ]),
+        }),
         ap_value: Optional({
             comment: "Generate AP values for each entry.",
             type: GenIncludeIdentifier(SelectOptionsAdventurePointsValue, [
@@ -357,6 +390,46 @@ const SelectOptionsFixedAdventurePointsValueMapping = GenTypeAlias(import.meta.u
         }),
     }),
 });
+const SelectOptionsBindingCostValue = GenEnum(import.meta.url, {
+    name: "SelectOptionsBindingCostValue",
+    comment: "Generate binding cost for each entry.",
+    parameters: [Param("Identifier")],
+    values: Identifier => ({
+        Fixed: EnumCase({
+            type: GenIncludeIdentifier(SelectOptionsFixedBindingCostValue, [TypeArgument(Identifier)]),
+        }),
+    }),
+});
+const SelectOptionsFixedBindingCostValue = GenTypeAlias(import.meta.url, {
+    name: "SelectOptionsFixedBindingCostValue",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        map: Required({
+            comment: "A mapping of skill identifiers to their specific binding cost values.",
+            type: Array(GenIncludeIdentifier(SelectOptionsFixedBindingCostValueMapping, [
+                TypeArgument(Identifier),
+            ])),
+        }),
+        default: Required({
+            comment: "The default value of an entry. Used as a fallback if no value is found in `list`.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const SelectOptionsFixedBindingCostValueMapping = GenTypeAlias(import.meta.url, {
+    name: "SelectOptionsFixedBindingCostValueMapping",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        id: Required({
+            comment: "The entry’s identifier.",
+            type: TypeArgument(Identifier),
+        }),
+        bindingCost: Required({
+            comment: "The binding cost for the specified entry.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
 const TargetCategoriesSelectOptionCategory = TypeAlias(import.meta.url, {
     name: "TargetCategoriesSelectOptionCategory",
     type: () => Object({

package/lib/types/_ActivatableSelectOptions.d.ts

@@ -12,6 +12,7 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
         Races: EnumCase<null>;
         Cultures: EnumCase<null>;
         RacesAndCultures: EnumCase<null>;
+        HomunculusTypes: EnumCase<null>;
         BlessedTraditions: EnumCase<IncludeIdentifier<[], TypeAlias<"BlessedTraditionsSelectOptionCategory", Object<{
             require_principles: import("tsondb/schema/def").MemberDecl<Boolean, false>;
         }>, []>>>;
@@ -659,6 +660,15 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
                     }, []>>>, false>;
                 }>, [Ref: import("tsondb/schema/def").TypeParameter<"Ref", import("tsondb/schema/def").Type>]>>>;
             }, []>>>, true>;
+            bindingCost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"SelectOptionsBindingCostValue", {
+                Fixed: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"SelectOptionsFixedBindingCostValue", Object<{
+                    map: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"SelectOptionsFixedBindingCostValueMapping", Object<{
+                        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>>, true>;
+                        bindingCost: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>, true>;
+                    default: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>;
+            }, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>, false>;
             ap_value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"SelectOptionsAdventurePointsValue", {
                 DerivedFromImprovementCost: EnumCase<IncludeIdentifier<[], TypeAlias<"SelectOptionsDeriveAdventurePointsValueFromImprovementCost", Object<{
                     multiplier: import("tsondb/schema/def").MemberDecl<Integer, false>;

package/lib/types/equipment/item/BandageOrRemedy.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const BandageOrRemedy = Entity(import.meta.url, {
     name: "BandageOrRemedy",
     namePlural: "BandagesAndRemedies",
@@ -35,4 +36,13 @@ export const BandageOrRemedy = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/CeremonialItem.js

@@ -2,6 +2,7 @@ import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/sc
 import { BlessedTraditionIdentifier } from "../../_Identifier.js";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const CeremonialItem = Entity(import.meta.url, {
     name: "CeremonialItem",
     namePlural: "CeremonialItems",
@@ -40,4 +41,13 @@ export const CeremonialItem = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/Clothes.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Clothes = Entity(import.meta.url, {
     name: "Clothes",
     namePlural: "Clothes",
@@ -35,4 +36,13 @@ export const Clothes = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/Container.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Container = Entity(import.meta.url, {
     name: "Container",
     namePlural: "Containers",
@@ -35,4 +36,13 @@ export const Container = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/EquipmentOfBlessedOnes.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Cost, DefaultItemTranslations, RestrictedTo, StructurePoints } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const EquipmentOfBlessedOnes = Entity(import.meta.url, {
     name: "EquipmentOfBlessedOnes",
     namePlural: "EquipmentOfBlessedOnes",
@@ -31,4 +32,13 @@ export const EquipmentOfBlessedOnes = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/IlluminationLightSource.js

@@ -1,6 +1,7 @@
 import { Entity, Enum, EnumCase, Float, IncludeIdentifier, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const IlluminationLightSource = Entity(import.meta.url, {
     name: "IlluminationLightSource",
     namePlural: "IlluminationLightSources",
@@ -39,6 +40,15 @@ export const IlluminationLightSource = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });
 const BurningTime = Enum(import.meta.url, {
     name: "BurningTime",

package/lib/types/equipment/item/IlluminationRefillOrSupply.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const IlluminationRefillOrSupply = Entity(import.meta.url, {
     name: "IlluminationRefillOrSupply",
     namePlural: "IlluminationRefillsAndSupplies",
@@ -35,4 +36,13 @@ export const IlluminationRefillOrSupply = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/Liebesspielzeug.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Liebesspielzeug = Entity(import.meta.url, {
     name: "Liebesspielzeug",
     namePlural: "Liebesspielzeug",
@@ -35,4 +36,13 @@ export const Liebesspielzeug = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/LuxuryGood.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const LuxuryGood = Entity(import.meta.url, {
     name: "LuxuryGood",
     namePlural: "LuxuryGoods",
@@ -35,4 +36,13 @@ export const LuxuryGood = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/MagicalArtifact.js

@@ -3,6 +3,7 @@ import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, StructurePoints, Weight } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const MagicalArtifact = Entity(import.meta.url, {
     name: "MagicalArtifact",
     namePlural: "MagicalArtifacts",
@@ -69,4 +70,13 @@ export const MagicalArtifact = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/MusicalInstrument.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const MusicalInstrument = Entity(import.meta.url, {
     name: "MusicalInstrument",
     namePlural: "MusicalInstruments",
@@ -35,4 +36,13 @@ export const MusicalInstrument = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

package/lib/types/equipment/item/TravelGearOrTool.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const TravelGearOrTool = Entity(import.meta.url, {
     name: "TravelGearOrTool",
     namePlural: "TravelGearAndTools",
@@ -35,4 +36,13 @@ export const TravelGearOrTool = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });