@optolith/database-schema 0.79.1 → 0.80.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.80.0](https://github.com/Optolith/database-schema/compare/v0.79.1...v0.80.0) (2026-10-06)
+
+### ⚠ BREAKING CHANGES
+
+* culture-only language specialization flag
+* invaluable item cost translation
+
+### Features
+
+* culture-only language specialization flag ([e7e35cd](https://github.com/Optolith/database-schema/commit/e7e35cdb78c9b1e92353f64bfb6858a32fdbdd40))
+* invaluable item cost translation ([61e6e22](https://github.com/Optolith/database-schema/commit/61e6e22b19a761309c4666ba03d4770c5a59e86d))
+
 ## [0.79.1](https://github.com/Optolith/database-schema/compare/v0.79.0...v0.79.1) (2026-10-05)
 
 ### Bug Fixes

package/gen/types.d.ts

@@ -736,6 +736,7 @@ export type TypeAliasMap = {
   IntoxicantAddictionCheck: IntoxicantAddictionCheck
   IntoxicantAddictionWithdrawalPrevention: IntoxicantAddictionWithdrawalPrevention
   IntoxicantLegality: IntoxicantLegality
+  InvaluableCost: InvaluableCost
   JesterTrickCastingTime: JesterTrickCastingTime
   JesterTrickCost: JesterTrickCost
   JesterTrickPerformanceParameters: JesterTrickPerformanceParameters
@@ -5714,6 +5715,11 @@ export interface LanguageSpecialization {
    */
   parent: Language_ID
 
+  /**
+   * The specialization is only mentioned in a culture’s description and not where the language itself is defined.
+   */
+  onlyForCulture: boolean
+
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
@@ -9862,7 +9868,7 @@ export interface CultureLanguageTranslation {
   specialization?: string
 
   /**
-   * A different promt fro the language specialization, if the language allows to specify arbitrary text.
+   * A different prompt for the language specialization, if the language allows to specify arbitrary text.
    */
   specializationPrompt?: string
 }
@@ -12417,6 +12423,7 @@ export type Cost =
   }
   | {
     kind: "Invaluable"
+    Invaluable: InvaluableCost
   }
   | {
     kind: "Fixed"
@@ -12427,6 +12434,22 @@ export type Cost =
     Range: CostRange
   }
 
+export interface InvaluableCost {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: InvaluableCostTranslation
+  }
+}
+
+export interface InvaluableCostTranslation {
+  /**
+   * The cost get wrapped by this text using a placeholder in the text.
+   */
+  wrap_in_text: string
+}
+
 export interface FixedCost {
   /**
    * The cost in silverthalers.

package/lib/types/Culture.js

@@ -122,7 +122,7 @@ const CultureLanguage = DB.TypeAlias(import.meta.url, {
                 type: DB.String({ minLength: 1 }),
             }),
             specializationPrompt: DB.Optional({
-                comment: "A different promt fro the language specialization, if the language allows to specify arbitrary text.",
+                comment: "A different prompt for the language specialization, if the language allows to specify arbitrary text.",
                 type: DB.String({ minLength: 1 }),
             }),
         }, { minProperties: 1 })),

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

@@ -3,7 +3,11 @@ export declare const Ammunition: DB.Entity<"Ammunition", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Animal: DB.Entity<"Animal", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -5,7 +5,11 @@ export declare const AnimalCare: DB.Entity<"AnimalCare", {
             cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                 Free: DB.EnumCase<null>;
                 Various: DB.EnumCase<null>;
-                Invaluable: DB.EnumCase<null>;
+                Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                        wrap_in_text: DB.MemberDecl<DB.String, true>;
+                    }>, false>;
+                }>, []>>>;
                 Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                     value: DB.MemberDecl<DB.Float, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Armor: DB.Entity<"Armor", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -19,7 +19,11 @@ export declare const Book: DB.Entity<"Book", {
                 cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                     Free: DB.EnumCase<null>;
                     Various: DB.EnumCase<null>;
-                    Invaluable: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
                     Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                         value: DB.MemberDecl<DB.Float, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -50,7 +54,11 @@ export declare const Book: DB.Entity<"Book", {
                 cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                     Free: DB.EnumCase<null>;
                     Various: DB.EnumCase<null>;
-                    Invaluable: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
                     Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                         value: DB.MemberDecl<DB.Float, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ 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>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Clothes: DB.Entity<"Clothes", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const ClothingPackage: DB.Entity<"ClothingPackage", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Container: DB.Entity<"Container", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const GemOrPreciousStone: DB.Entity<"GemOrPreciousStone", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -4,7 +4,11 @@ export declare const Item: DB.Entity<"Item", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Laboratory: DB.Entity<"Laboratory", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Newspaper: DB.Entity<"Newspaper", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -2,7 +2,11 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
     cost: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"Cost", {
         Free: import("tsondb/schema/dsl").EnumCase<null>;
         Various: import("tsondb/schema/dsl").EnumCase<null>;
-        Invaluable: import("tsondb/schema/dsl").EnumCase<null>;
+        Invaluable: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"InvaluableCost", import("tsondb/schema/dsl").Object<{
+            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"FixedCost", import("tsondb/schema/dsl").Object<{
             value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Float, true>;
             translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"FixedCostTranslation", {

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

@@ -2,7 +2,11 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
     cost: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"Cost", {
         Free: import("tsondb/schema/dsl").EnumCase<null>;
         Various: import("tsondb/schema/dsl").EnumCase<null>;
-        Invaluable: import("tsondb/schema/dsl").EnumCase<null>;
+        Invaluable: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"InvaluableCost", import("tsondb/schema/dsl").Object<{
+            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"FixedCost", import("tsondb/schema/dsl").Object<{
             value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Float, true>;
             translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"FixedCostTranslation", {

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

@@ -2,7 +2,11 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
     cost: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"Cost", {
         Free: import("tsondb/schema/dsl").EnumCase<null>;
         Various: import("tsondb/schema/dsl").EnumCase<null>;
-        Invaluable: import("tsondb/schema/dsl").EnumCase<null>;
+        Invaluable: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"InvaluableCost", import("tsondb/schema/dsl").Object<{
+            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"FixedCost", import("tsondb/schema/dsl").Object<{
             value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Float, true>;
             translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"FixedCostTranslation", {

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

@@ -2,7 +2,11 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
     cost: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"Cost", {
         Free: import("tsondb/schema/dsl").EnumCase<null>;
         Various: import("tsondb/schema/dsl").EnumCase<null>;
-        Invaluable: import("tsondb/schema/dsl").EnumCase<null>;
+        Invaluable: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"InvaluableCost", import("tsondb/schema/dsl").Object<{
+            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"FixedCost", import("tsondb/schema/dsl").Object<{
             value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Float, true>;
             translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const ToolOfTheTrade: DB.Entity<"ToolOfTheTrade", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Vehicle: DB.Entity<"Vehicle", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Weapon: DB.Entity<"Weapon", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const WorkingSupernaturalCreature: DB.Entity<"WorkingSupernatural
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -396,7 +400,11 @@ export declare const StructurePoints: DB.TypeAlias<"StructurePoints", DB.Array<D
 export declare const Cost: DB.Enum<"Cost", {
     Free: DB.EnumCase<null>;
     Various: DB.EnumCase<null>;
-    Invaluable: DB.EnumCase<null>;
+    Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+        translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+            wrap_in_text: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, []>>>;
     Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
         value: DB.MemberDecl<DB.Float, true>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -102,7 +102,7 @@ export const Cost = DB.Enum(import.meta.url, {
     values: () => ({
         Free: DB.EnumCase({ type: null }),
         Various: DB.EnumCase({ type: null }),
-        Invaluable: DB.EnumCase({ type: null }),
+        Invaluable: DB.EnumCase({ type: DB.IncludeIdentifier(InvaluableCost) }),
         Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedCost) }),
         Range: DB.EnumCase({ type: DB.IncludeIdentifier(CostRange) }),
     }),
@@ -111,6 +111,14 @@ const wrap_in_text = DB.Required({
     comment: "The cost get wrapped by this text using a placeholder in the text.",
     type: DB.String({ minLength: 1, pattern: /\{0\}/ }),
 });
+const InvaluableCost = DB.TypeAlias(import.meta.url, {
+    name: "InvaluableCost",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "InvaluableCost", DB.Object({
+            wrap_in_text,
+        })),
+    }),
+});
 export const FixedCost = DB.TypeAlias(import.meta.url, {
     name: "FixedCost",
     type: () => DB.Object({

package/lib/types/specialAbility/sub/Language.d.ts

@@ -6,6 +6,7 @@ export declare const Language: DB.Entity<"Language", {
     }>, []>>>, true>;
     specializations: DB.MemberDecl<DB.ChildEntities<DB.Entity<"LanguageSpecialization", {
         parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        onlyForCulture: DB.MemberDecl<DB.Boolean, true>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"LanguageSpecializationTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             description: DB.MemberDecl<DB.String, false>;
@@ -102,6 +103,7 @@ export declare const Language: DB.Entity<"Language", {
 }, undefined>;
 export declare const LanguageSpecialization: DB.Entity<"LanguageSpecialization", {
     parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    onlyForCulture: DB.MemberDecl<DB.Boolean, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"LanguageSpecializationTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         description: DB.MemberDecl<DB.String, false>;

package/lib/types/specialAbility/sub/Language.js

@@ -63,6 +63,10 @@ export const LanguageSpecialization = DB.Entity(import.meta.url, {
             comment: "The language this specialization belongs to.",
             type: LanguageIdentifier(),
         }),
+        onlyForCulture: DB.Required({
+            comment: "The specialization is only mentioned in a culture’s description and not where the language itself is defined.",
+            type: DB.Boolean(),
+        }),
         translations: NestedTranslationMap(DB.Required, "LanguageSpecialization", DB.Object({
             name: DB.Required({
                 comment: "The specialization’s name.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.79.1",
+  "version": "0.80.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",