@optolith/database-schema 0.42.1

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

@@ -0,0 +1,420 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
+        Spirit: DB.EnumCase<null>;
+        HalfOfSpirit: DB.EnumCase<null>;
+        Toughness: DB.EnumCase<null>;
+        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        SummoningDifficulty: DB.EnumCase<null>;
+        CreationDifficulty: DB.EnumCase<null>;
+        Object: DB.EnumCase<null>;
+    }, []>>, false>;
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ZibiljaRitualPerformanceParameters", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"OneTimePerformanceParameters", DB.Object<{
+        casting_time: DB.MemberDecl<DB.TypeArgument<DB.Param<"CastingTime", DB.Type>>, true>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"OneTimeCost", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SingleOneTimeCost", {
+                Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableOneTimeCost", DB.Object<{
+                    initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ModifiableOneTimeCostTranslation", {
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                NonModifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCost", DB.Object<{
+                    is_minimum: DB.MemberDecl<DB.Boolean, false>;
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCostPerCountable", DB.Object<{
+                        minimum_total: DB.MemberDecl<DB.Integer, false>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostPerCountableTranslation", {
+                            countable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                                full: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, []>>, true>;
+                        }>, true>;
+                    }>, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
+                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteOneTimeCost", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteOneTimeCostTranslation", {
+                        description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>>;
+            Conjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MultipleOneTimeCosts", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SingleOneTimeCost", {
+                Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableOneTimeCost", DB.Object<{
+                    initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ModifiableOneTimeCostTranslation", {
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                NonModifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCost", DB.Object<{
+                    is_minimum: DB.MemberDecl<DB.Boolean, false>;
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCostPerCountable", DB.Object<{
+                        minimum_total: DB.MemberDecl<DB.Integer, false>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostPerCountableTranslation", {
+                            countable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                                full: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, []>>, true>;
+                        }>, true>;
+                    }>, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
+                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteOneTimeCost", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteOneTimeCostTranslation", {
+                        description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>>, []>>>;
+            Disjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MultipleOneTimeCosts", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SingleOneTimeCost", {
+                Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableOneTimeCost", DB.Object<{
+                    initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ModifiableOneTimeCostTranslation", {
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                NonModifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCost", DB.Object<{
+                    is_minimum: DB.MemberDecl<DB.Boolean, false>;
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCostPerCountable", DB.Object<{
+                        minimum_total: DB.MemberDecl<DB.Integer, false>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostPerCountableTranslation", {
+                            countable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                                full: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, []>>, true>;
+                        }>, true>;
+                    }>, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
+                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                    }>, false>;
+                }>, []>>>;
+                Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteOneTimeCost", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteOneTimeCostTranslation", {
+                        description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, true>;
+                        }>, []>>, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>>, []>>>;
+            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMap", DB.Object<{
+                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMapOption", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapOptionTranslation", {
+                        label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, true>;
+                        label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, []>>>, true>;
+                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MapStyle", {
+                    Compressed: DB.EnumCase<null>;
+                    Verbose: DB.EnumCase<null>;
+                }, []>>, false>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapTranslation", {
+                    list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+        }, []>>, true>;
+        range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Range", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeValue", {
+                Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableRange", DB.Object<{
+                    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                    initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    is_radius: DB.MemberDecl<DB.Boolean, false>;
+                }>, []>>>;
+                Sight: DB.EnumCase<null>;
+                Self: DB.EnumCase<null>;
+                Global: DB.EnumCase<null>;
+                Touch: DB.EnumCase<null>;
+                Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedRange", DB.Object<{
+                    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                        Steps: DB.EnumCase<null>;
+                        Miles: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    is_radius: DB.MemberDecl<DB.Boolean, false>;
+                }>, []>>>;
+                CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedRange", 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<"RangeUnit", {
+                        Steps: DB.EnumCase<null>;
+                        Miles: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    is_radius: DB.MemberDecl<DB.Boolean, false>;
+                }>, []>>>;
+            }, []>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"RangeTranslation", {
+                note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, false>;
+                }>, []>>, false>;
+                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>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationForOneTime", {
+            Immediate: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Immediate", DB.Object<{
+                maximum: 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<"ImmediateTranslation", {
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Permanent: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PermanentDuration", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"PermanentDurationTranslation", {
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedDuration", DB.Object<{
+                is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                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>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"FixedDurationTranslation", {
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            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>;
+            }>, []>>>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteDuration", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteDurationTranslation", {
+                    description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+    }>, [CastingTime: DB.Param<"CastingTime", DB.Type>]>>, []>>, true>;
+    target: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AffectedTargetCategories", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificAffectedTargetCategory", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecificAffectedTargetCategoryIdentifier", {
+            Self: DB.EnumCase<null>;
+            Zone: DB.EnumCase<null>;
+            LiturgicalChantsAndCeremonies: DB.EnumCase<null>;
+            Cantrips: DB.EnumCase<null>;
+            Spellworks: DB.EnumCase<null>;
+            Predefined: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificAffectedTargetCategoryTranslation", {
+            note: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, []>>>, []>>, true>;
+    property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+        A: DB.EnumCase<null>;
+        B: DB.EnumCase<null>;
+        C: DB.EnumCase<null>;
+        D: DB.EnumCase<null>;
+    }, []>>, 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>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ZibiljaRitualTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        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>;
+        casting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        range: 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>;
+        target: 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/ZibiljaRitual.js

@@ -0,0 +1,90 @@
+import * as DB from "tsondb/schema/dsl";
+import { OldParameter, OneTimePerformanceParameters } from "../_ActivatableSkill.js";
+import { CastingTime, SlowSkillNonModifiableCastingTime } from "../_ActivatableSkillCastingTime.js";
+import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
+import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js";
+import { PropertyIdentifier } from "../_Identifier.js";
+import { ImprovementCost } from "../_ImprovementCost.js";
+import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const ZibiljaRitual = DB.Entity(import.meta.url, {
+    name: "ZibiljaRitual",
+    namePlural: "ZibiljaRituals",
+    type: () => DB.Object({
+        check: DB.Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        check_penalty: DB.Optional({
+            comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+            type: DB.IncludeIdentifier(SkillCheckPenalty),
+        }),
+        parameters: DB.Required({
+            comment: "Measurable parameters of a zibilja ritual.",
+            type: DB.IncludeIdentifier(ZibiljaRitualPerformanceParameters),
+        }),
+        target: DB.Required({
+            comment: "The target category – the kind of creature or object – the skill affects.",
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
+        }),
+        property: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        improvement_cost: DB.Required({
+            comment: "States which column is used to improve the skill.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "ZibiljaRitual", DB.Object({
+            name: DB.Required({
+                comment: "The zibilja ritual’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            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),
+            }),
+            casting_time: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            cost: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            range: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            duration: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            target: DB.Optional({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const ZibiljaRitualPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "ZibiljaRitualPerformanceParameters",
+    type: () => DB.GenIncludeIdentifier(OneTimePerformanceParameters, [
+        DB.GenIncludeIdentifier(CastingTime, [
+            DB.IncludeIdentifier(SlowSkillNonModifiableCastingTime),
+        ]),
+    ]),
+});

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

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const MusicTraditionReference: (traditionIdentifier: DB.ReferenceIdentifier) => DB.TypeAlias<string, DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<`${string}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}>, []>;
+export declare const MusicDuration: DB.TypeAlias<"MusicDuration", DB.Object<{
+    length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MusicLength", {
+        Long: DB.EnumCase<null>;
+        Short: DB.EnumCase<null>;
+    }, []>>, true>;
+    reusability: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MusicReusability", {
+        OneTime: DB.EnumCase<null>;
+        Sustainable: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;

package/lib/types/magicalActions/_MusicTradition.js

@@ -0,0 +1,43 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../Locale.js";
+export const MusicTraditionReference = (traditionIdentifier) => DB.TypeAlias(import.meta.url, {
+    name: traditionIdentifier.entity.name + "Reference",
+    comment: "A reference to a music tradition with the music-tradition-specific name of the entry.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The music tradition’s identifier.",
+            type: traditionIdentifier,
+        }),
+        translations: NestedTranslationMap(DB.Required, traditionIdentifier.entity.name + "ReferenceTranslation", DB.Object({
+            name: DB.Required({
+                comment: "The music-tradition-specific name of the entry.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+export const MusicDuration = DB.TypeAlias(import.meta.url, {
+    name: "MusicDuration",
+    type: () => DB.Object({
+        length: DB.Required({
+            type: DB.IncludeIdentifier(MusicLength),
+        }),
+        reusability: DB.Required({
+            type: DB.IncludeIdentifier(MusicReusability),
+        }),
+    }),
+});
+const MusicLength = DB.Enum(import.meta.url, {
+    name: "MusicLength",
+    values: () => ({
+        Long: DB.EnumCase({ type: null }),
+        Short: DB.EnumCase({ type: null }),
+    }),
+});
+const MusicReusability = DB.Enum(import.meta.url, {
+    name: "MusicReusability",
+    values: () => ({
+        OneTime: DB.EnumCase({ type: null }),
+        Sustainable: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/prerequisites/ConditionalPrerequisites.d.ts

@@ -0,0 +1,42 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Preconditions: 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>;
+    }>, []>>>;
+}, []>>>, []>;

package/lib/types/prerequisites/ConditionalPrerequisites.js

@@ -0,0 +1,9 @@
+import * as DB from "tsondb/schema/dsl";
+import { PreconditionGroup } from "./PrerequisiteGroups.js";
+export const Preconditions = DB.TypeAlias(import.meta.url, {
+    name: "Preconditions",
+    comment: `A list of preconditions for the prerequisite it is defined on, so that it only takes effect if the prerequisites in this list are matched.
+
+Usually appears at the \`when\` property of the parent prerequisite.`,
+    type: () => DB.Array(DB.IncludeIdentifier(PreconditionGroup), { minItems: 1 }),
+});

package/lib/types/prerequisites/DisplayOption.d.ts

@@ -0,0 +1,13 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const DisplayOption: 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>;
+    }>, []>>>;
+}, []>;