npm - @optolith/database-schema - Versions diffs - 0.92.0 → 0.94.0 - Mend

@optolith/database-schema 0.92.0 → 0.94.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

package/lib/types/equipment/item/Jewelry.d.ts CHANGED Viewed

@@ -15,6 +15,30 @@ export declare const Jewelry: DB.Entity<"Jewelry", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const Laboratory: DB.Entity<"Laboratory", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -27,6 +27,30 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
         Simple: import("tsondb/schema/dsl").EnumCase<null>;
         Complex: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ComplexComplexity", import("tsondb/schema/dsl").Object<{
             ap_value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+            prerequisites: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PlainGeneralPrerequisites", import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PlainPrerequisites", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").Enum<"PrerequisitesElement", {
+                Single: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>;
+                Disjunction: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisitesDisjunction", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    display_option: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"DisplayOption", {
+                        Hide: import("tsondb/schema/dsl").EnumCase<null>;
+                        ReplaceWith: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ReplacementDisplayOption", import("tsondb/schema/dsl").Object<{
+                            sentence_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"SentenceType", {
+                                Standalone: import("tsondb/schema/dsl").EnumCase<null>;
+                                Connected: import("tsondb/schema/dsl").EnumCase<null>;
+                            }, []>>, false>;
+                            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+                Group: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisiteGroup", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                    }>, true>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+            }, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>, []>>, false>;
             src: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRefs", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRef", import("tsondb/schema/dsl").Object<{
                 id: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
                 occurrences: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<string, {

package/lib/types/equipment/item/Poison.d.ts CHANGED Viewed

@@ -283,9 +283,6 @@ export declare const Poison: DB.Entity<"Poison", {
                     value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>>;
             }, []>>, true>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"DemonicPoisonTranslation", {
-                note: DB.MemberDecl<DB.String, false>;
-            }>, false>;
         }>, []>>>;
     }, []>>, true>;
     resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
@@ -712,9 +709,6 @@ export declare const DemonicPoison: DB.TypeAlias<"DemonicPoison", DB.Object<{
             value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>;
     }, []>>, true>;
-    translations: DB.MemberDecl<DB.NestedEntityMap<"DemonicPoisonTranslation", {
-        note: DB.MemberDecl<DB.String, false>;
-    }>, false>;
 }>, []>;
 export declare const QualityLevelDemonicPoisonLevel: DB.TypeAlias<"QualityLevelDemonicPoisonLevel", DB.Object<{
     source: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"QualityLevelDemonicPoisonLevelSource", {

package/lib/types/equipment/item/Poison.js CHANGED Viewed

@@ -329,12 +329,6 @@ export const DemonicPoison = DB.TypeAlias(import.meta.url, {
             comment: "The poison’s level.",
             type: DB.IncludeIdentifier(DemonicPoisonLevel),
         }),
-        translations: NestedTranslationMap(DB.Optional, "DemonicPoison", DB.Object({
-            note: DB.Optional({
-                comment: "A note, if any.",
-                type: DB.String({ minLength: 1, markdown: "block" }),
-            }),
-        }, { minProperties: 1 })),
     }),
 });
 const DemonicPoisonLevel = DB.Enum(import.meta.url, {

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

@@ -27,6 +27,30 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
         Simple: import("tsondb/schema/dsl").EnumCase<null>;
         Complex: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ComplexComplexity", import("tsondb/schema/dsl").Object<{
             ap_value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+            prerequisites: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PlainGeneralPrerequisites", import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PlainPrerequisites", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").Enum<"PrerequisitesElement", {
+                Single: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>;
+                Disjunction: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisitesDisjunction", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    display_option: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"DisplayOption", {
+                        Hide: import("tsondb/schema/dsl").EnumCase<null>;
+                        ReplaceWith: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ReplacementDisplayOption", import("tsondb/schema/dsl").Object<{
+                            sentence_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"SentenceType", {
+                                Standalone: import("tsondb/schema/dsl").EnumCase<null>;
+                                Connected: import("tsondb/schema/dsl").EnumCase<null>;
+                            }, []>>, false>;
+                            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+                Group: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisiteGroup", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                    }>, true>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+            }, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>, []>>, false>;
             src: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRefs", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRef", import("tsondb/schema/dsl").Object<{
                 id: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
                 occurrences: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<string, {

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

@@ -27,6 +27,30 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
         Simple: import("tsondb/schema/dsl").EnumCase<null>;
         Complex: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ComplexComplexity", import("tsondb/schema/dsl").Object<{
             ap_value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+            prerequisites: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PlainGeneralPrerequisites", import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PlainPrerequisites", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").Enum<"PrerequisitesElement", {
+                Single: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>;
+                Disjunction: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisitesDisjunction", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    display_option: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"DisplayOption", {
+                        Hide: import("tsondb/schema/dsl").EnumCase<null>;
+                        ReplaceWith: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ReplacementDisplayOption", import("tsondb/schema/dsl").Object<{
+                            sentence_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"SentenceType", {
+                                Standalone: import("tsondb/schema/dsl").EnumCase<null>;
+                                Connected: import("tsondb/schema/dsl").EnumCase<null>;
+                            }, []>>, false>;
+                            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+                Group: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisiteGroup", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                    }>, true>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+            }, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>, []>>, false>;
             src: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRefs", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRef", import("tsondb/schema/dsl").Object<{
                 id: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
                 occurrences: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<string, {

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

@@ -27,6 +27,30 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
         Simple: import("tsondb/schema/dsl").EnumCase<null>;
         Complex: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ComplexComplexity", import("tsondb/schema/dsl").Object<{
             ap_value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+            prerequisites: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PlainGeneralPrerequisites", import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PlainPrerequisites", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").Enum<"PrerequisitesElement", {
+                Single: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>;
+                Disjunction: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisitesDisjunction", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    display_option: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"DisplayOption", {
+                        Hide: import("tsondb/schema/dsl").EnumCase<null>;
+                        ReplaceWith: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ReplacementDisplayOption", import("tsondb/schema/dsl").Object<{
+                            sentence_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"SentenceType", {
+                                Standalone: import("tsondb/schema/dsl").EnumCase<null>;
+                                Connected: import("tsondb/schema/dsl").EnumCase<null>;
+                            }, []>>, false>;
+                            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+                Group: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisiteGroup", import("tsondb/schema/dsl").Object<{
+                    list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+                    translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                    }>, true>;
+                }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+            }, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>, []>>, false>;
             src: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRefs", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRef", import("tsondb/schema/dsl").Object<{
                 id: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
                 occurrences: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<string, {

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

@@ -28,6 +28,30 @@ export declare const ToolOfTheTrade: DB.Entity<"ToolOfTheTrade", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -28,6 +28,30 @@ export declare const Vehicle: DB.Entity<"Vehicle", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

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

@@ -21,13 +21,37 @@ export declare const Weapon: DB.Entity<"Weapon", {
                 wrap_in_text: DB.MemberDecl<DB.String, true>;
             }>, false>;
         }>, []>>>;
-    }, []>>, true>;
-    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    }, []>>, false>;
+    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>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {

package/lib/types/equipment/item/Weapon.js CHANGED Viewed

@@ -11,11 +11,11 @@ export const Weapon = DB.Entity(import.meta.url, {
     name: "Weapon",
     namePlural: "Weapons",
     type: () => DB.Object({
-        cost: DB.Required({
+        cost: DB.Optional({
             comment: "The cost in silverthalers.",
             type: DB.IncludeIdentifier(Cost),
         }),
-        weight: DB.Required({
+        weight: DB.Optional({
             comment: "The weight in kg.",
             type: DB.IncludeIdentifier(Weight),
         }),

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

@@ -28,6 +28,30 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             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, {