optolith-database-schema 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.37.0](https://github.com/elyukai/optolith-database-schema/compare/v0.36.1...v0.37.0) (2026-03-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* more detailed book rules and meta data
+
+### Features
+
+* more detailed book rules and meta data ([04b3a74](https://github.com/elyukai/optolith-database-schema/commit/04b3a7451e8ccc629b670da95b178f115085363b))
+
+## [0.36.1](https://github.com/elyukai/optolith-database-schema/compare/v0.36.0...v0.36.1) (2026-03-13)
+
+
+### Features
+
+* cost map style ([127cc6c](https://github.com/elyukai/optolith-database-schema/commit/127cc6cc48ea1c77ab4e31eb424ddc92c2cb248e))
+
 ## [0.36.0](https://github.com/elyukai/optolith-database-schema/compare/v0.35.0...v0.36.0) (2026-03-13)
 
 

package/gen/types.d.ts

@@ -237,8 +237,10 @@ export type EnumMap = {
   BlessedTraditionType: BlessedTraditionType
   BlessingDuration: BlessingDuration
   BlessingRange: BlessingRange
+  BookContentQuality: BookContentQuality
   BookCost: BookCost
   BookCostVariant: BookCostVariant
+  BookRules: BookRules
   BookType: BookType
   BurningTime: BurningTime
   CantripDuration: CantripDuration
@@ -325,6 +327,7 @@ export type EnumMap = {
   MagicalSignCost: MagicalSignCost
   MagicalTraditionPrerequisiteRestriction: MagicalTraditionPrerequisiteRestriction
   MagicCommonProfessionConstraint: MagicCommonProfessionConstraint
+  MapStyle: MapStyle
   MathOperation: MathOperation<unknown>
   MaximumIndefiniteCurseDuration: MaximumIndefiniteCurseDuration
   MaximumIndefiniteDominationRitualDuration: MaximumIndefiniteDominationRitualDuration
@@ -483,6 +486,8 @@ export type TypeAliasMap = {
   BlessedTraditionPrerequisite: BlessedTraditionPrerequisite
   BlessedTraditionsSelectOptionCategory: BlessedTraditionsSelectOptionCategory
   BlessingPerformanceParameters: BlessingPerformanceParameters
+  BookRulesByEdition: BookRulesByEdition
+  BookRulesOfEdition: BookRulesOfEdition
   BySizeCategory: BySizeCategory<unknown>
   CalculationTranslation: CalculationTranslation
   CantripPerformanceParameters: CantripPerformanceParameters
@@ -702,6 +707,7 @@ export type TypeAliasMap = {
   PersonalityTraitEffect: PersonalityTraitEffect
   PersonalityTraitPrerequisite: PersonalityTraitPrerequisite
   PersonalityTraitPrerequisites: PersonalityTraitPrerequisites
+  PlainBookRules: PlainBookRules
   PlainCommonProfessions: PlainCommonProfessions
   PlainGeneralPrerequisites: PlainGeneralPrerequisites
   PlainPrerequisites: PlainPrerequisites<unknown>
@@ -2433,6 +2439,24 @@ export interface Locale {
     ".input {$count :number} {{check required every {$count}. application in the same month}}": string & { __params: { "count": number } }
     "see {$link}": string & { __params: { "link": StringableTranslationParameter } }
     "CoD": string
+    "Romance Novel": string
+    "Poetry": string
+    "Political Pamphlet": string
+    "Crime Story": string
+    "Fairy Tale": string
+    "Novel": string
+    "Professional Publication": string
+    "Magical Book": string
+    "Religious Works": string
+    "Content Quality": string
+    "Modest": string
+    "Average": string
+    "Demanding": string
+    "CL {$level}": string & { __params: { "level": StringableTranslationParameter } }
+    "Availability": string
+    "Reconstruction": string
+    "References": string
+    "Entertainment": string
     "Failed": string
     "Progress": string
     "Incubation Time": string
@@ -5839,6 +5863,11 @@ export interface OneTimeCostMap {
    */
   options: OneTimeCostMapOption[]
 
+  /**
+   * The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`). The default is `compressed`.
+   */
+  style?: MapStyle
+
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
@@ -5895,6 +5924,17 @@ export interface OneTimeCostMapOptionTranslation {
   label_standalone?: ResponsiveTextOptional
 }
 
+/**
+ * The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`).
+ */
+export type MapStyle =
+  | {
+    kind: "Compressed"
+  }
+  | {
+    kind: "Verbose"
+  }
+
 export interface Range {
   /**
    * The range value.
@@ -19999,6 +20039,11 @@ export interface Book {
    */
   structure_points?: StructurePoints
 
+  /**
+   * The quality of the book’s content.
+   */
+  contentQuality?: BookContentQuality
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -20046,7 +20091,22 @@ export interface BookTranslation {
   /**
    * Special rules text.
    */
-  rules?: string
+  rules?: BookRules
+
+  /**
+   * The legality of the item, if specified.
+   */
+  legality?: string
+
+  /**
+   * The availability of the item, if specified.
+   */
+  availability?: string
+
+  /**
+   * Special properties or features of the item.
+   */
+  special?: string
 
   errata?: Errata
 }
@@ -20167,6 +20227,96 @@ export interface IndefiniteBookCostVariantTranslation {
   description: string
 }
 
+/**
+ * The quality of the book’s content.
+ */
+export type BookContentQuality =
+  | {
+    kind: "Modest"
+  }
+  | {
+    kind: "Average"
+  }
+  | {
+    kind: "Demanding"
+    Demanding: number
+  }
+
+/**
+ * Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.
+ */
+export type BookRules =
+  | {
+    kind: "Plain"
+    Plain: PlainBookRules
+  }
+  | {
+    kind: "Entertainment"
+  }
+  | {
+    kind: "ByEdition"
+    ByEdition: BookRulesByEdition
+  }
+
+/**
+ * The book’s rules without any special effects or conditions.
+ */
+export interface PlainBookRules {
+  /**
+   * The (main) rules text.
+   */
+  text: string
+
+  /**
+   * Rules for reconstructing certain skills or abilities from the book.
+   */
+  reconstruction?: string
+
+  /**
+   * References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.
+   */
+  references?: string
+
+  /**
+   * Additional rules text that comes after all other rules.
+   */
+  textAfter?: string
+}
+
+/**
+ * The book’s rules with differences between each edition and more differentiation between types of rules.
+ */
+export interface BookRulesByEdition {
+  editions: BookRulesOfEdition[]
+
+  /**
+   * Rules for reconstructing certain skills or abilities from the book.
+   */
+  reconstruction?: string
+
+  /**
+   * References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.
+   */
+  references?: string
+
+  /**
+   * Additional rules text that comes after all other rules.
+   */
+  textAfter?: string
+}
+
+export interface BookRulesOfEdition {
+  /**
+   * The edition(s) the rules apply to.
+   */
+  label: string
+
+  /**
+   * The rules text.
+   */
+  text: string
+}
+
 export interface CeremonialItem {
   /**
    * The cost in silverthalers.

package/lib/types/Ceremony.d.ts

@@ -149,6 +149,10 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                             }>, []>>, 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>;

package/lib/types/LiturgicalChant.d.ts

@@ -149,6 +149,10 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                             }>, []>>, 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>;

package/lib/types/Locale.d.ts

@@ -1477,6 +1477,24 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$count :number} {{check required every {$count}. application in the same month}}": null;
         "see {$link}": null;
         CoD: null;
+        "Romance Novel": null;
+        Poetry: null;
+        "Political Pamphlet": null;
+        "Crime Story": null;
+        "Fairy Tale": null;
+        Novel: null;
+        "Professional Publication": null;
+        "Magical Book": null;
+        "Religious Works": null;
+        "Content Quality": null;
+        Modest: null;
+        Average: null;
+        Demanding: null;
+        "CL {$level}": null;
+        Availability: null;
+        Reconstruction: null;
+        References: null;
+        Entertainment: null;
         Failed: null;
         Progress: null;
         "Incubation Time": null;

package/lib/types/Locale.js

@@ -1518,6 +1518,25 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$count :number} {{check required every {$count}. application in the same month}}": null,
                 "see {$link}": null,
                 "CoD": null,
+                // books
+                "Romance Novel": null,
+                "Poetry": null,
+                "Political Pamphlet": null,
+                "Crime Story": null,
+                "Fairy Tale": null,
+                "Novel": null,
+                "Professional Publication": null,
+                "Magical Book": null,
+                "Religious Works": null,
+                "Content Quality": null,
+                "Modest": null,
+                "Average": null,
+                "Demanding": null,
+                "CL {$level}": null,
+                "Availability": null,
+                "Reconstruction": null,
+                "References": null,
+                "Entertainment": null,
                 // sex practices
                 "Failed": null,
                 // diseases

package/lib/types/Ritual.d.ts

@@ -149,6 +149,10 @@ export declare const Ritual: DB.Entity<"Ritual", {
                             }>, []>>, 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>;

package/lib/types/Spell.d.ts

@@ -149,6 +149,10 @@ export declare const Spell: DB.Entity<"Spell", {
                             }>, []>>, 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>;

package/lib/types/_ActivatableSkill.d.ts

@@ -140,6 +140,10 @@ export declare const OneTimePerformanceParameters: DB.TypeAlias<"OneTimePerforma
                     }>, []>>, 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>;
@@ -442,6 +446,10 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                         }>, []>>, 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>;
@@ -893,6 +901,10 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                         }>, []>>, 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>;

package/lib/types/_ActivatableSkillCost.d.ts

@@ -135,6 +135,10 @@ export declare const OneTimeCost: DB.Enum<"OneTimeCost", {
                 }>, []>>, 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>;
@@ -183,6 +187,10 @@ export declare const OneTimeCostMap: DB.TypeAlias<"OneTimeCostMap", DB.Object<{
             }>, []>>, 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>;
@@ -198,6 +206,10 @@ export declare const OneTimeCostMap: DB.TypeAlias<"OneTimeCostMap", DB.Object<{
         }>, []>>, false>;
     }>, false>;
 }>, []>;
+export declare const MapStyle: DB.Enum<"MapStyle", {
+    Compressed: DB.EnumCase<null>;
+    Verbose: DB.EnumCase<null>;
+}, []>;
 export declare const SustainedCost: DB.Enum<"SustainedCost", {
     Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableSustainedCost", DB.Object<{
         initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;

package/lib/types/_ActivatableSkillCost.js

@@ -123,6 +123,10 @@ This will generate the exact same string as seen above – given it is set for a
                 minItems: 2,
             }),
         }),
+        style: DB.Optional({
+            comment: "The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`). The default is `compressed`.",
+            type: DB.IncludeIdentifier(MapStyle),
+        }),
         translations: NestedTranslationMap(DB.Optional, "OneTimeCostMap", DB.Object({
             list_prepend: DB.Optional({
                 comment: "Place a string between the `for` and the grouped map option labels.",
@@ -162,6 +166,14 @@ const OneTimeCostMapOption = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
+export const MapStyle = DB.Enum(import.meta.url, {
+    name: "MapStyle",
+    comment: "The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`).",
+    values: () => ({
+        Compressed: DB.EnumCase({ type: null }),
+        Verbose: DB.EnumCase({ type: null }),
+    }),
+});
 export const SustainedCost = DB.Enum(import.meta.url, {
     name: "SustainedCost",
     values: () => ({

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

@@ -88,6 +88,11 @@ export declare const Book: DB.Entity<"Book", {
     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, {
@@ -135,7 +140,27 @@ export declare const Book: DB.Entity<"Book", {
         language: DB.MemberDecl<DB.String, false>;
         script: DB.MemberDecl<DB.String, false>;
         note: DB.MemberDecl<DB.String, false>;
-        rules: 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>;
+                }>, []>>>, true>;
+                reconstruction: DB.MemberDecl<DB.String, false>;
+                references: DB.MemberDecl<DB.String, false>;
+                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>;

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

@@ -28,6 +28,10 @@ export const Book = DB.Entity(import.meta.url, {
             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({
@@ -52,6 +56,18 @@ export const Book = DB.Entity(import.meta.url, {
             }),
             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({
@@ -179,3 +195,77 @@ const IndefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
+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 }),
+        }),
+        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 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" }),
+        }),
+    }),
+});

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

@@ -28,6 +28,10 @@ export declare const GeodeRitual: DB.Entity<"GeodeRitual", {
                         }>, []>>, 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>;

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

@@ -148,6 +148,10 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                         }>, []>>, 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>;

package/lib/types/specialAbility/MagicalSign.d.ts

@@ -47,6 +47,10 @@ export declare const MagicalSign: DB.Entity<"MagicalSign", {
                     }>, []>>, 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",