@optolith/database-schema 0.42.1

package/lib/types/magicalActions/AnimistPower.d.ts

@@ -0,0 +1,302 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AnimistPower: DB.Entity<"AnimistPower", {
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnimistPowerPerformanceParameters", {
+        OneTime: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeAnimistPowerPerformanceParameters", DB.Object<{
+            cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"OneTimeAnimistPowerCost", {
+                Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedOneTimeAnimistPowerCost", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
+                        }, []>>, true>;
+                    }>, []>>, false>;
+                }>, []>>>;
+                ByPrimaryPatron: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimistPowerCostByPrimaryPatron", DB.Object<{
+                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
+                        }, []>>, true>;
+                    }>, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"AnimistPowerCostByPrimaryPatronTranslation", {
+                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+            }, []>>, true>;
+            duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"OneTimeAnimistPowerDuration", {
+                Immediate: DB.EnumCase<null>;
+                Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                        Seconds: DB.EnumCase<null>;
+                        Minutes: DB.EnumCase<null>;
+                        Hours: DB.EnumCase<null>;
+                        Days: DB.EnumCase<null>;
+                        Weeks: DB.EnumCase<null>;
+                        Months: DB.EnumCase<null>;
+                        Years: DB.EnumCase<null>;
+                        Centuries: DB.EnumCase<null>;
+                        Actions: DB.EnumCase<null>;
+                        CombatRounds: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
+                    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                    base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
+                        QualityLevels: DB.EnumCase<null>;
+                        SkillPoints: DB.EnumCase<null>;
+                        SkillRating: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
+                        arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
+                            Multiply: DB.EnumCase<null>;
+                            Divide: DB.EnumCase<null>;
+                        }, []>>, true>;
+                        value: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>, false>;
+                    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                        Seconds: DB.EnumCase<null>;
+                        Minutes: DB.EnumCase<null>;
+                        Hours: DB.EnumCase<null>;
+                        Days: DB.EnumCase<null>;
+                        Weeks: DB.EnumCase<null>;
+                        Months: DB.EnumCase<null>;
+                        Years: DB.EnumCase<null>;
+                        Centuries: DB.EnumCase<null>;
+                        Actions: DB.EnumCase<null>;
+                        CombatRounds: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"CheckResultBasedDurationTranslation", {
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, []>>>;
+            }, []>>, true>;
+        }>, []>>>;
+        Sustained: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SustainedAnimistPowerPerformanceParameters", DB.Object<{
+            cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SustainedAnimistPowerCost", {
+                Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedSustainedAnimistPowerCost", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
+                        }, []>>, true>;
+                    }>, []>>, true>;
+                }>, []>>>;
+                ByPrimaryPatron: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimistPowerCostByPrimaryPatron", DB.Object<{
+                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
+                        }, []>>, true>;
+                    }>, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"AnimistPowerCostByPrimaryPatronTranslation", {
+                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+            }, []>>, true>;
+        }>, []>>>;
+    }, []>>, true>;
+    property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    tribe_tradition: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnimistPowerImprovementCost", {
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+            A: DB.EnumCase<null>;
+            B: DB.EnumCase<null>;
+            C: DB.EnumCase<null>;
+            D: DB.EnumCase<null>;
+        }, []>>>;
+        ByPrimaryPatron: DB.EnumCase<null>;
+    }, []>>, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimistPowerPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, 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>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+    levels: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimistPowerLevel", DB.Object<{
+        level: DB.MemberDecl<DB.Integer, true>;
+        src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+                initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, false>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                    isRemoved: DB.MemberDecl<DB.Boolean, false>;
+                }>, []>>, true>;
+                revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                    Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, true>;
+                        pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                            first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, true>;
+                            last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                    }>, []>>>;
+                    Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                }, []>>>, false>;
+            }>, true>;
+        }>, []>>>, []>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"AnimistPowerLevelTranslation", {
+            effect: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, []>>>, false>;
+    src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"AnimistPowerTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        name_in_library: DB.MemberDecl<DB.String, false>;
+        effect: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableSkillEffect", {
+            Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillPlainEffect", DB.Object<{
+                text: DB.MemberDecl<DB.String, true>;
+            }>, []>>>;
+            ForEachQualityLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachQualityLevel", DB.Object<{
+                text_before: DB.MemberDecl<DB.String, true>;
+                quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+                text_after: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+            ForEachTwoQualityLevels: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", DB.Object<{
+                text_before: DB.MemberDecl<DB.String, true>;
+                quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+                text_after: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+        }, []>>, true>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        prerequisites: DB.MemberDecl<DB.String, false>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/magicalActions/AnimistPower.js

@@ -0,0 +1,204 @@
+import * as DB from "tsondb/schema/dsl";
+import { name_in_library } from "../_Activatable.js";
+import { OldParameter } from "../_ActivatableSkill.js";
+import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js";
+import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
+import { PropertyIdentifier, TribeIdentifier } from "../_Identifier.js";
+import { ImprovementCost } from "../_ImprovementCost.js";
+import { AnimistPowerPrerequisites } from "../_Prerequisite.js";
+import { ResponsiveTextOptional } from "../_ResponsiveText.js";
+import { SkillCheck } from "../_SkillCheck.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { PublicationRefs, src } from "../source/_PublicationRef.js";
+export const AnimistPower = DB.Entity(import.meta.url, {
+    name: "AnimistPower",
+    namePlural: "AnimistPowers",
+    type: () => DB.Object({
+        check: DB.Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        parameters: DB.Required({
+            comment: "Measurable parameters of an animist power.",
+            type: DB.IncludeIdentifier(AnimistPowerPerformanceParameters),
+        }),
+        property: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        tribe_tradition: DB.Required({
+            comment: `The tribe traditions the animist power is available to. It may be available to all or only specific tribes.
+
+If no tribe tradition is given, the animist power is generally available to all tribe traditions.`,
+            type: DB.Array(TribeIdentifier(), { uniqueItems: true }),
+        }),
+        improvement_cost: DB.Required({
+            comment: "States which column is used to improve the skill.",
+            type: DB.IncludeIdentifier(AnimistPowerImprovementCost),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites for the animist power.",
+            type: DB.IncludeIdentifier(AnimistPowerPrerequisites),
+        }),
+        levels: DB.Optional({
+            comment: "The animist power can have multiple levels. Each level is skilled separately. A previous level must be on at least 10 so that the next higher level can be activated and skilled. A higher level cannot be skilled higher than a lower level. Each level also adds an effect text to the text of the first level.",
+            type: DB.Array(DB.IncludeIdentifier(AnimistPowerLevel), { minItems: 1 }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "AnimistPower", DB.Object({
+            name: DB.Required({
+                comment: "The animist power’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            name_in_library,
+            effect: DB.Required({
+                comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+                type: DB.IncludeIdentifier(ActivatableSkillEffect),
+            }),
+            cost: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            duration: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            prerequisites: DB.Optional({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const AnimistPowerLevel = DB.TypeAlias(import.meta.url, {
+    name: "AnimistPowerLevel",
+    type: () => DB.Object({
+        level: DB.Required({
+            comment: "The level number.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        src: DB.Optional({
+            comment: "The source references, if different than the references for level 1.",
+            type: DB.IncludeIdentifier(PublicationRefs),
+        }),
+        translations: NestedTranslationMap(DB.Required, "AnimistPowerLevel", DB.Object({
+            effect: DB.Required({
+                comment: "An additional effect description for this level.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const AnimistPowerPerformanceParameters = DB.Enum(import.meta.url, {
+    name: "AnimistPowerPerformanceParameters",
+    comment: "Measurable parameters of an animist power.",
+    values: () => ({
+        OneTime: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeAnimistPowerPerformanceParameters) }),
+        Sustained: DB.EnumCase({
+            type: DB.IncludeIdentifier(SustainedAnimistPowerPerformanceParameters),
+        }),
+    }),
+});
+const OneTimeAnimistPowerPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "OneTimeAnimistPowerPerformanceParameters",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The AE cost value, either a flat value or defined dynamically by the primary patron.",
+            type: DB.IncludeIdentifier(OneTimeAnimistPowerCost),
+        }),
+        duration: DB.Required({
+            comment: "The duration.",
+            type: DB.IncludeIdentifier(OneTimeAnimistPowerDuration),
+        }),
+    }),
+});
+const OneTimeAnimistPowerCost = DB.Enum(import.meta.url, {
+    name: "OneTimeAnimistPowerCost",
+    values: () => ({
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedOneTimeAnimistPowerCost) }),
+        ByPrimaryPatron: DB.EnumCase({ type: DB.IncludeIdentifier(AnimistPowerCostByPrimaryPatron) }),
+    }),
+});
+const FixedOneTimeAnimistPowerCost = DB.TypeAlias(import.meta.url, {
+    name: "FixedOneTimeAnimistPowerCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (temporary) AE cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Optional({
+            comment: "If defined, the AE cost has to be paid each interval.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const AnimistPowerCostByPrimaryPatron = DB.TypeAlias(import.meta.url, {
+    name: "AnimistPowerCostByPrimaryPatron",
+    type: () => DB.Object({
+        interval: DB.Optional({
+            comment: "If defined, half of the AE cost `value` has to be paid each interval.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "AnimistPowerCostByPrimaryPatron", DB.Object({
+            note: DB.Required({
+                comment: "A note, appended to the generated string in parenthesis.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+        })),
+    }),
+});
+const OneTimeAnimistPowerDuration = DB.Enum(import.meta.url, {
+    name: "OneTimeAnimistPowerDuration",
+    values: () => ({
+        Immediate: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    }),
+});
+const SustainedAnimistPowerPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "SustainedAnimistPowerPerformanceParameters",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The AE cost value, either a flat value or defined dynamically by the primary patron.",
+            type: DB.IncludeIdentifier(SustainedAnimistPowerCost),
+        }),
+    }),
+});
+const SustainedAnimistPowerCost = DB.Enum(import.meta.url, {
+    name: "SustainedAnimistPowerCost",
+    values: () => ({
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedSustainedAnimistPowerCost) }),
+        ByPrimaryPatron: DB.EnumCase({ type: DB.IncludeIdentifier(AnimistPowerCostByPrimaryPatron) }),
+    }),
+});
+const FixedSustainedAnimistPowerCost = DB.TypeAlias(import.meta.url, {
+    name: "FixedSustainedAnimistPowerCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (temporary) AE cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Required({
+            comment: "Half of the AE cost `value` has to be paid each interval.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const AnimistPowerImprovementCost = DB.Enum(import.meta.url, {
+    name: "AnimistPowerImprovementCost",
+    values: () => ({
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(ImprovementCost) }),
+        ByPrimaryPatron: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/magicalActions/AnimistPower_Tribe.d.ts

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Tribe: DB.Entity<"Tribe", {
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TribePrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, 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>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"TribeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/magicalActions/AnimistPower_Tribe.js

@@ -0,0 +1,26 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../Locale.js";
+import { TribePrerequisites } from "../_Prerequisite.js";
+export const Tribe = DB.Entity(import.meta.url, {
+    name: "Tribe",
+    namePlural: "Tribes",
+    type: () => DB.Object({
+        prerequisites: DB.Required({
+            comment: "The prerequisite(s) to be of this tribe.",
+            type: DB.IncludeIdentifier(TribePrerequisites),
+        }),
+        translations: NestedTranslationMap(DB.Required, "Tribe", DB.Object({
+            name: DB.Required({
+                comment: "The tribe’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});