@optolith/database-schema 0.42.1

package/lib/types/equipment/item/Book.d.ts

@@ -0,0 +1,169 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Book: DB.Entity<"Book", {
+    types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"BookType", {
+        Mundane: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"MundaneBookType", {
+            RomanceNovel: DB.EnumCase<null>;
+            Poetry: DB.EnumCase<null>;
+            PoliticalPamphlet: DB.EnumCase<null>;
+            CrimeStory: DB.EnumCase<null>;
+            FairyTale: DB.EnumCase<null>;
+            Novel: DB.EnumCase<null>;
+            ProfessionalPublication: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>>;
+        Magical: DB.EnumCase<null>;
+        Religious: DB.EnumCase<null>;
+    }, []>>>, true>;
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookCost", {
+        Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"BookCostVariant", {
+            Definite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefiniteBookCostVariant", DB.Object<{
+                cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+                    Free: DB.EnumCase<null>;
+                    Various: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<null>;
+                    Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+                        value: DB.MemberDecl<DB.Float, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
+                    Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+                        from: DB.MemberDecl<DB.Float, true>;
+                        to: DB.MemberDecl<DB.Float, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
+                }, []>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"DefiniteBookCostVariantTranslation", {
+                    label: DB.MemberDecl<DB.String, false>;
+                }>, false>;
+            }>, []>>>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteBookCostVariant", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteBookCostVariantTranslation", {
+                    label: DB.MemberDecl<DB.String, false>;
+                    description: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>>;
+        Multiple: DB.EnumCase<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"BookCostVariant", {
+            Definite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefiniteBookCostVariant", DB.Object<{
+                cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+                    Free: DB.EnumCase<null>;
+                    Various: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<null>;
+                    Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+                        value: DB.MemberDecl<DB.Float, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
+                    Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+                        from: DB.MemberDecl<DB.Float, true>;
+                        to: DB.MemberDecl<DB.Float, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
+                }, []>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"DefiniteBookCostVariantTranslation", {
+                    label: DB.MemberDecl<DB.String, false>;
+                }>, false>;
+            }>, []>>>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteBookCostVariant", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteBookCostVariantTranslation", {
+                    label: DB.MemberDecl<DB.String, false>;
+                    description: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>>>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
+        points: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>, []>>, false>;
+    contentQuality: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookContentQuality", {
+        Modest: DB.EnumCase<null>;
+        Average: DB.EnumCase<null>;
+        Demanding: DB.EnumCase<DB.Integer>;
+    }, []>>, 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<"BookTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        language: DB.MemberDecl<DB.String, false>;
+        script: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookRules", {
+            Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainBookRules", DB.Object<{
+                text: DB.MemberDecl<DB.String, true>;
+                reconstruction: DB.MemberDecl<DB.String, false>;
+                references: DB.MemberDecl<DB.String, false>;
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+            Entertainment: DB.EnumCase<null>;
+            ByEdition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesByEdition", DB.Object<{
+                editions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesOfEdition", DB.Object<{
+                    label: DB.MemberDecl<DB.String, true>;
+                    text: DB.MemberDecl<DB.String, true>;
+                    reconstruction: DB.MemberDecl<DB.String, false>;
+                    references: DB.MemberDecl<DB.String, false>;
+                }>, []>>>, true>;
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+        }, []>>, false>;
+        legality: DB.MemberDecl<DB.String, false>;
+        availability: DB.MemberDecl<DB.String, false>;
+        special: 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/equipment/item/Book.js

@@ -0,0 +1,271 @@
+import * as DB from "tsondb/schema/dsl";
+import { SkillIdentifier } from "../../_Identifier.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity, Cost, StructurePoints, Weight } from "./_Item.js";
+export const Book = DB.Entity(import.meta.url, {
+    name: "Book",
+    namePlural: "Books",
+    type: () => DB.Object({
+        types: DB.Required({
+            comment: "The type of book.",
+            type: DB.Array(DB.IncludeIdentifier(BookType), { minItems: 1, uniqueItems: true }),
+        }),
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(BookCost),
+        }),
+        weight: DB.Optional({
+            comment: "The weight in kg.",
+            type: DB.IncludeIdentifier(Weight),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        structure_points: DB.Optional({
+            comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+            type: DB.IncludeIdentifier(StructurePoints),
+        }),
+        contentQuality: DB.Optional({
+            comment: "The quality of the book’s content.",
+            type: DB.IncludeIdentifier(BookContentQuality),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Book", DB.Object({
+            name: DB.Required({
+                comment: "The item’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            secondary_name: DB.Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            language: DB.Optional({
+                comment: "The language the book is written in, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            script: DB.Optional({
+                comment: "The script that was used for the book, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            note: DB.Optional({
+                comment: "Note text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            rules: DB.Optional({
+                comment: "Special rules text.",
+                type: DB.IncludeIdentifier(BookRules),
+            }),
+            legality: DB.Optional({
+                comment: "The legality of the item, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            availability: DB.Optional({
+                comment: "The availability of the item, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            special: DB.Optional({
+                comment: "Special properties or features of the item.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const BookType = DB.Enum(import.meta.url, {
+    name: "BookType",
+    comment: "The type of book.",
+    values: () => ({
+        Mundane: DB.EnumCase({
+            comment: "A mundane book without special rules.",
+            type: DB.IncludeIdentifier(MundaneBookType),
+        }),
+        Magical: DB.EnumCase({
+            comment: "A magical book.",
+            type: null,
+        }),
+        Religious: DB.EnumCase({
+            comment: "A religious book.",
+            type: null,
+        }),
+    }),
+});
+const MundaneBookType = DB.Enum(import.meta.url, {
+    name: "MundaneBookType",
+    comment: "The type of mundane book, i.e. the type of writing it contains.",
+    values: () => ({
+        RomanceNovel: DB.EnumCase({
+            comment: "A romance novel.",
+            type: null,
+        }),
+        Poetry: DB.EnumCase({
+            comment: "A piece of poetry.",
+            type: null,
+        }),
+        PoliticalPamphlet: DB.EnumCase({
+            comment: "A political pamphlet.",
+            type: null,
+        }),
+        CrimeStory: DB.EnumCase({
+            comment: "A crime story.",
+            type: null,
+        }),
+        FairyTale: DB.EnumCase({
+            comment: "A fairy tale.",
+            type: null,
+        }),
+        Novel: DB.EnumCase({
+            comment: "A novel.",
+            type: null,
+        }),
+        ProfessionalPublication: DB.EnumCase({
+            comment: "A professional publication about a specific topic, represented by a (knowledge) skill.",
+            type: SkillIdentifier(),
+        }),
+    }),
+});
+const BookCost = DB.Enum(import.meta.url, {
+    name: "BookCost",
+    comment: "The cost of the book, which may be a single value or multiple values that are defined by specific editions or other defining factors of the book.",
+    values: () => ({
+        Single: DB.EnumCase({
+            comment: "The book only has a single cost description.",
+            type: DB.IncludeIdentifier(BookCostVariant),
+        }),
+        Multiple: DB.EnumCase({
+            comment: "The book’s cost varies by edition or other factors.",
+            type: DB.Array(DB.IncludeIdentifier(BookCostVariant), { minItems: 2 }),
+        }),
+    }),
+});
+const BookCostVariant = DB.Enum(import.meta.url, {
+    name: "BookCostVariant",
+    comment: "A variant for the book’s cost.",
+    values: () => ({
+        Definite: DB.EnumCase({
+            comment: "A definite cost value.",
+            type: DB.IncludeIdentifier(DefiniteBookCostVariant),
+        }),
+        Indefinite: DB.EnumCase({
+            comment: "An indefinite cost value.",
+            type: DB.IncludeIdentifier(IndefiniteBookCostVariant),
+        }),
+    }),
+});
+const DefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
+    name: "DefiniteBookCostVariant",
+    comment: "A definite cost value for the book, such as a specific cost or cost range.",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(Cost),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "DefiniteBookCostVariant", DB.Object({
+            label: DB.Optional({
+                comment: "The label for the cost variant, e.g. “Original script”.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const IndefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
+    name: "IndefiniteBookCostVariant",
+    comment: "An indefinite cost value for the book, which means it is impossible to narrow the range of the cost value by any numbers.",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "IndefiniteBookCostVariant", DB.Object({
+            label: DB.Optional({
+                comment: "The label for the cost variant, e.g. “Original script”.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            description: DB.Required({
+                comment: "The description of the cost variant, e.g. “less”.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const BookContentQuality = DB.Enum(import.meta.url, {
+    name: "BookContentQuality",
+    comment: "The quality of the book’s content.",
+    values: () => ({
+        Modest: DB.EnumCase({ type: null }),
+        Average: DB.EnumCase({ type: null }),
+        Demanding: DB.EnumCase({ type: DB.Integer({ minimum: 1, maximum: 3 }) }),
+    }),
+});
+const BookRules = DB.Enum(import.meta.url, {
+    name: "BookRules",
+    comment: "Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.",
+    values: () => ({
+        Plain: DB.EnumCase({ type: DB.IncludeIdentifier(PlainBookRules) }),
+        Entertainment: DB.EnumCase({ type: null }),
+        ByEdition: DB.EnumCase({ type: DB.IncludeIdentifier(BookRulesByEdition) }),
+    }),
+});
+const PlainBookRules = DB.TypeAlias(import.meta.url, {
+    name: "PlainBookRules",
+    comment: "The book’s rules without any special effects or conditions.",
+    type: () => DB.Object({
+        text: DB.Required({
+            comment: "The (main) rules text.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        reconstruction: DB.Optional({
+            comment: "Rules for reconstructing certain skills or abilities from the book.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        references: DB.Optional({
+            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        textAfter: DB.Optional({
+            comment: "Additional rules text that comes after all other rules.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const BookRulesByEdition = DB.TypeAlias(import.meta.url, {
+    name: "BookRulesByEdition",
+    comment: "The book’s rules with differences between each edition and more differentiation between types of rules.",
+    type: () => DB.Object({
+        editions: DB.Required({
+            type: DB.Array(DB.IncludeIdentifier(BookRulesOfEdition), { minItems: 1 }),
+        }),
+        textAfter: DB.Optional({
+            comment: "Additional rules text that comes after all other rules.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const BookRulesOfEdition = DB.TypeAlias(import.meta.url, {
+    name: "BookRulesOfEdition",
+    type: () => DB.Object({
+        label: DB.Required({
+            comment: "The edition(s) the rules apply to.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        text: DB.Required({
+            comment: "The rules text.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        reconstruction: DB.Optional({
+            comment: "Rules for reconstructing certain skills or abilities from the book.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        references: DB.Optional({
+            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});

package/lib/types/equipment/item/CeremonialItem.d.ts

@@ -0,0 +1,202 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<null>;
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+        Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+            from: DB.MemberDecl<DB.Float, true>;
+            to: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
+        points: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>, []>>, false>;
+    associated_tradition: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    combat_use: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatUse", {
+        Weapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ImprovisedWeapon", DB.Object<{
+            melee_uses: DB.MemberDecl<DB.NestedEntityMap<string, {
+                damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+                damage_threshold: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PrimaryAttributeDamageThreshold", {
+                    Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultPrimaryAttributeDamageThreshold", DB.Object<{
+                        threshold: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                    List: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PrimaryAttributeDamageThresholdList", DB.Object<{
+                        list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SinglePrimaryAttributeDamageThreshold", DB.Object<{
+                            attribute: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                            threshold: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+                attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
+                parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
+                reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+                length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+                size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
+                    Small: DB.EnumCase<null>;
+                    Medium: DB.EnumCase<null>;
+                    Large: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LargeShieldSize", DB.Object<{
+                        attack_penalty: DB.MemberDecl<DB.Integer, false>;
+                    }>, []>>>;
+                }, []>>, false>;
+                is_parrying_weapon: DB.MemberDecl<DB.Boolean, true>;
+                is_two_handed_weapon: DB.MemberDecl<DB.Boolean, true>;
+                is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+            }>, false>;
+            ranged_uses: DB.MemberDecl<DB.NestedEntityMap<string, {
+                damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+                reload_time: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ReloadTime", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>, true>;
+                range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RangeBrackets", DB.Object<{
+                    close: DB.MemberDecl<DB.Integer, true>;
+                    medium: DB.MemberDecl<DB.Integer, true>;
+                    far: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, true>;
+                ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
+                length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+                is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+            }>, false>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+                races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                        Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                        Church: DB.EnumCase<null>;
+                        Shamanistic: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ImprovisedWeaponTranslation", {
+                advantage: DB.MemberDecl<DB.String, false>;
+                disadvantage: DB.MemberDecl<DB.String, false>;
+            }>, false>;
+        }>, []>>>;
+        Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
+            protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
+            encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
+                Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
+                    combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{
+                        armors: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                        protection: DB.MemberDecl<DB.Integer, false>;
+                    }>, []>>, false>;
+                }>, []>>>;
+                Torso: DB.EnumCase<null>;
+                Arms: DB.EnumCase<null>;
+                Legs: DB.EnumCase<null>;
+            }, []>>, false>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+                races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                        Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                        Church: DB.EnumCase<null>;
+                        Shamanistic: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SecondaryArmorTranslation", {
+                advantage: DB.MemberDecl<DB.String, false>;
+                disadvantage: DB.MemberDecl<DB.String, false>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, 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<`${string}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: 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>;