@optolith/database-schema 0.42.1

package/lib/types/rule/OptionalRule.d.ts

@@ -0,0 +1,83 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const OptionalRule: DB.Entity<"OptionalRule", {
+    isMissingImplementation: DB.MemberDecl<DB.Boolean, true>;
+    complexityInfluence: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ComplexityInfluence", {
+        Less: DB.EnumCase<null>;
+        Unchanged: DB.EnumCase<null>;
+        More: DB.EnumCase<null>;
+    }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisites", 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, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"OptionalRuleTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, true>;
+        additionalRules: DB.MemberDecl<DB.String, false>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/rule/OptionalRule.js

@@ -0,0 +1,59 @@
+import * as DB from "tsondb/schema/dsl";
+import { RulePrerequisites } from "../_Prerequisite.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const OptionalRule = DB.Entity(import.meta.url, {
+    name: "OptionalRule",
+    namePlural: "OptionalRules",
+    type: () => DB.Object({
+        isMissingImplementation: DB.Required({
+            comment: "Has the optional rule not been implemented in Optolith yet? This is also true if the optional rule does not (currently) apply to any Optolith feature.",
+            type: DB.Boolean(),
+        }),
+        complexityInfluence: DB.Optional({
+            comment: "How this optional rule influences the complexity of the game, if specified.",
+            type: DB.IncludeIdentifier(ComplexityInfluence),
+        }),
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(RulePrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "OptionalRule", DB.Object({
+            name: DB.Required({
+                comment: "The optional rule’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The description of the optional rule, as stated in the optional rule box.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            additionalRules: DB.Optional({
+                comment: "Sometimes, an optional rule does not only contain all the rules belonging to it in its rule box, but also in the main text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const ComplexityInfluence = DB.Enum(import.meta.url, {
+    name: "ComplexityInfluence",
+    comment: "How this optional rule influences the complexity of the game.",
+    values: () => ({
+        Less: DB.EnumCase({ comment: "The optional rule makes the game less complex.", type: null }),
+        Unchanged: DB.EnumCase({
+            comment: "The optional rule does not change the complexity of the game.",
+            type: null,
+        }),
+        More: DB.EnumCase({ comment: "The optional rule makes the game more complex.", type: null }),
+    }),
+});

package/lib/types/source/Publication.d.ts

@@ -0,0 +1,50 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Publication: DB.Entity<"Publication", {
+    category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PublicationCategory", {
+        CoreRules: DB.EnumCase<null>;
+        ExpansionRules: DB.EnumCase<null>;
+        Sourcebook: DB.EnumCase<null>;
+        RegionalSourcebook: DB.EnumCase<null>;
+        Adventure: DB.EnumCase<null>;
+    }, []>>, true>;
+    containsAdultContent: DB.MemberDecl<DB.Boolean, true>;
+    isMissingImplementation: DB.MemberDecl<DB.Boolean, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisites", 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>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PublicationTranslation", {
+        publisherId: DB.MemberDecl<DB.String, false>;
+        name: DB.MemberDecl<DB.String, true>;
+        abbreviation: DB.MemberDecl<DB.String, true>;
+        release_date: DB.MemberDecl<DB.Date, false>;
+        isMissingImplementation: DB.MemberDecl<DB.Boolean, true>;
+    }>, true>;
+}, undefined>;
+export declare const PublicationCategory: DB.Enum<"PublicationCategory", {
+    CoreRules: DB.EnumCase<null>;
+    ExpansionRules: DB.EnumCase<null>;
+    Sourcebook: DB.EnumCase<null>;
+    RegionalSourcebook: DB.EnumCase<null>;
+    Adventure: DB.EnumCase<null>;
+}, []>;

package/lib/types/source/Publication.js

@@ -0,0 +1,64 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../Locale.js";
+import { PublicationPrerequisites } from "../_Prerequisite.js";
+export const Publication = DB.Entity(import.meta.url, {
+    name: "Publication",
+    namePlural: "Publications",
+    comment: "A (usually physical) self-contained document with rules and crunch elements relevant for character creation, character development, and game play.",
+    type: () => DB.Object({
+        category: DB.Required({
+            comment: "The publication category.",
+            type: DB.IncludeIdentifier(PublicationCategory),
+        }),
+        containsAdultContent: DB.Required({
+            comment: "If the publication may contain adult content.",
+            type: DB.Boolean(),
+        }),
+        isMissingImplementation: DB.Required({
+            comment: "If the publication is not (fully) implemented and thus needs to be excluded from stable releases.",
+            type: DB.Boolean(),
+        }),
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(PublicationPrerequisites),
+        }),
+        translations: NestedTranslationMap(DB.Required, "Publication", DB.Object({
+            publisherId: DB.Optional({
+                comment: "The publisher’s publication identifier.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            name: DB.Required({
+                comment: "The publication’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            abbreviation: DB.Required({
+                comment: "The publication’s abbreviation.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            release_date: DB.Optional({
+                comment: "The publication’s release date.",
+                type: DB.Date(),
+            }),
+            isMissingImplementation: DB.Required({
+                comment: "If this publication translation is not (fully) implemented and thus needs to be excluded from stable releases.",
+                type: DB.Boolean(),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+export const PublicationCategory = DB.Enum(import.meta.url, {
+    name: "PublicationCategory",
+    values: () => ({
+        CoreRules: DB.EnumCase({ type: null }),
+        ExpansionRules: DB.EnumCase({ type: null }),
+        Sourcebook: DB.EnumCase({ type: null }),
+        RegionalSourcebook: DB.EnumCase({ type: null }),
+        Adventure: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/source/_Erratum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @main Errata
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const Errata: DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+    date: DB.MemberDecl<DB.Date, true>;
+    description: DB.MemberDecl<DB.String, true>;
+}>, []>>>, []>;
+export declare const Erratum: DB.TypeAlias<"Erratum", DB.Object<{
+    date: DB.MemberDecl<DB.Date, true>;
+    description: DB.MemberDecl<DB.String, true>;
+}>, []>;

package/lib/types/source/_Erratum.js

@@ -0,0 +1,22 @@
+/**
+ * @main Errata
+ */
+import * as DB from "tsondb/schema/dsl";
+export const Errata = DB.TypeAlias(import.meta.url, {
+    name: "Errata",
+    comment: "A list of errata for the entry in the specific language.",
+    type: () => DB.Array(DB.IncludeIdentifier(Erratum), { minItems: 1 }),
+});
+export const Erratum = DB.TypeAlias(import.meta.url, {
+    name: "Erratum",
+    type: () => DB.Object({
+        date: DB.Required({
+            comment: "The date when the change was confirmed and applied to the entry.",
+            type: DB.Date(),
+        }),
+        description: DB.Required({
+            comment: "A description of what changed.",
+            type: DB.String({ minLength: 1 }),
+        }),
+    }),
+});

package/lib/types/source/_PublicationRef.d.ts

@@ -0,0 +1,168 @@
+/**
+ * @main PublicationRefs
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const PublicationRefs: DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+        initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+            printing: DB.MemberDecl<DB.Integer, false>;
+            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, true>;
+                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, false>;
+            }>, []>>>, true>;
+            isRemoved: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>, true>;
+        revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+            Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>>;
+            Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, false>;
+    }>, true>;
+}>, []>>>, []>;
+export declare const src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+        initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+            printing: DB.MemberDecl<DB.Integer, false>;
+            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, true>;
+                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, false>;
+            }>, []>>>, true>;
+            isRemoved: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>, true>;
+        revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+            Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>>;
+            Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, false>;
+    }>, true>;
+}>, []>>>, []>>, true>;
+export declare const optionalSrc: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+        initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+            printing: DB.MemberDecl<DB.Integer, false>;
+            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, true>;
+                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, false>;
+            }>, []>>>, true>;
+            isRemoved: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>, true>;
+        revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+            Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>>;
+            Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, false>;
+    }>, true>;
+}>, []>>>, []>>, false>;
+export declare const PublicationRef: DB.TypeAlias<"PublicationRef", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+        initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+            printing: DB.MemberDecl<DB.Integer, false>;
+            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, true>;
+                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                    InsideCoverFront: DB.EnumCase<null>;
+                    InsideCoverBack: DB.EnumCase<null>;
+                    Numbered: DB.EnumCase<DB.Integer>;
+                }, []>>, false>;
+            }>, []>>>, true>;
+            isRemoved: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>, true>;
+        revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+            Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>>;
+            Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, false>;
+    }>, true>;
+}>, []>;

package/lib/types/source/_PublicationRef.js

@@ -0,0 +1,164 @@
+/**
+ * @main PublicationRefs
+ */
+import * as DB from "tsondb/schema/dsl";
+import { PublicationIdentifier } from "../_Identifier.js";
+import { Locale } from "../Locale.js";
+export const PublicationRefs = DB.TypeAlias(import.meta.url, {
+    name: "PublicationRefs",
+    comment: "The publications where you can find the entry.",
+    type: () => DB.Array(DB.IncludeIdentifier(PublicationRef), { minItems: 1 }),
+});
+const srcConfig = {
+    displayName: "Source References",
+    comment: "References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.",
+    type: DB.IncludeIdentifier(PublicationRefs),
+};
+export const src = DB.Required(srcConfig);
+export const optionalSrc = DB.Optional(srcConfig);
+export const PublicationRef = DB.TypeAlias(import.meta.url, {
+    name: "PublicationRef",
+    comment: "A source reference. It contains the book's publisher identifier and the page where it occurs. If an entry spans multiple pages, provide the last page as well.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The publication’s identifier.",
+            type: PublicationIdentifier(),
+        }),
+        occurrences: DB.Required({
+            comment: "All translations for the entry, identified by IETF language tag (BCP47).",
+            type: DB.NestedEntityMap({
+                name: "Occurrence",
+                namePlural: "Occurrences",
+                secondaryEntity: Locale,
+                type: DB.Object({
+                    initial: DB.Required({
+                        comment: "The initial occurrence of the entry.",
+                        type: DB.IncludeIdentifier(InitialOccurrence),
+                    }),
+                    revisions: DB.Optional({
+                        comment: "Revisions of the entry, resulting in either changed page references or re-addition or removal of an entry.",
+                        type: DB.Array(DB.IncludeIdentifier(Revision), { minItems: 1 }),
+                    }),
+                }),
+                minProperties: 1,
+            }),
+        }),
+    }),
+});
+const InitialOccurrence = DB.TypeAlias(import.meta.url, {
+    name: "InitialOccurrence",
+    type: () => DB.Object({
+        printing: DB.Optional({
+            comment: "The publication’s printing since which the entry is present. Leave empty if present since the beginning.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        pages: DB.Required({
+            comment: "The initial page references.",
+            type: DB.Array(DB.IncludeIdentifier(PageRange), { minItems: 1 }),
+        }),
+        isRemoved: DB.Optional({
+            comment: "Whether the entry has been removed in this initial occurrence. This can be used if the entry has been removed by the release of this publication (that is, the first printing), which can be useful for books that introduce major revisions of rules into the game.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+// const PrintingOccurrences = DB.TypeAlias(import.meta.url, {
+//   name: "PrintingOccurrences",
+//   comment: "The history of changes this publication’s printings introduced.",
+//   type: () => DB.Array(DB.IncludeIdentifier(PrintingOccurrence), { minItems: 1 }),
+//   customConstraints: ({ value }) => {
+//     const firstEntry = value[0]
+//     if (!firstEntry) {
+//       return ["At least one printing occurrence must be provided."]
+//     }
+//     if (firstEntry.printing > 1 && firstEntry.changes.kind === "Remove") {
+//       return [
+//         "The first printing occurrence cannot be a removal if the printing number is greater than 1. It must have been present in the previous printing then, which needs to be provided.",
+//       ]
+//     }
+//     return []
+//   },
+// })
+// const _PrintingOccurrence = DB.TypeAlias(import.meta.url, {
+//   name: "PrintingOccurrence",
+//   comment: "The publication’s printing where the entry has been added, changed, or removed.",
+//   type: () =>
+//     DB.Object({
+//       printing: DB.Required({
+//         comment: "The printing number.",
+//         type: DB.Integer({ minimum: 1 }),
+//       }),
+//       changes: DB.Required({
+//         comment: "The changes made in this printing.",
+//         type: DB.IncludeIdentifier(PrintingChanges),
+//       }),
+//     }),
+// })
+// const PrintingChanges = DB.Enum(import.meta.url, {
+//   name: "PrintingChanges",
+//   comment:
+//     "A revision of the entry, resulting in either changed page references or re-addition or removal of an entry.",
+//   values: () => ({
+//     Set: DB.EnumCase({
+//       comment:
+//         "The entry has been added, re-added or changed page(s) in this printing. The page references override any previously set ones in case an entry has been moved to a different page in a later printing.",
+//       type: DB.Array(DB.IncludeIdentifier(PageRange), { minItems: 1 }),
+//     }),
+//     Remove: DB.EnumCase({
+//       comment:
+//         "The entry has been removed in this printing.\n\nThis can also be used if the entry hss been removed by the release of this publication (that is, the first printing), which can be useful for books that introduce major revisions of rules into the game.",
+//       type: null,
+//     }),
+//   }),
+// })
+const Revision = DB.Enum(import.meta.url, {
+    name: "Revision",
+    comment: "A revision of the entry, resulting in either changed page references or re-addition or removal of an entry.",
+    values: () => ({
+        Since: DB.EnumCase({ type: DB.IncludeIdentifier(Since) }),
+        Deprecated: DB.EnumCase({ type: DB.IncludeIdentifier(Deprecation) }),
+    }),
+});
+const Since = DB.TypeAlias(import.meta.url, {
+    name: "Since",
+    type: () => DB.Object({
+        printing: DB.Required({
+            comment: "The publication’s printing since which the entry is present again or has changed page references.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        pages: DB.Required({
+            comment: "The changed or new page references.",
+            type: DB.Array(DB.IncludeIdentifier(PageRange), { minItems: 1 }),
+        }),
+    }),
+});
+const Deprecation = DB.TypeAlias(import.meta.url, {
+    name: "Deprecation",
+    type: () => DB.Object({
+        printing: DB.Required({
+            comment: "The publication’s printing since which the entry has been removed.\n\nThis can also be used if the entry hss been removed by the release of this publication (that is, the first printing).",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const PageRange = DB.TypeAlias(import.meta.url, {
+    name: "PageRange",
+    type: () => DB.Object({
+        first_page: DB.Required({
+            comment: "The page where it occurs. If the entry spans multiple pages, use this as the first page and `last_page` as the last page.",
+            type: DB.IncludeIdentifier(Page),
+        }),
+        last_page: DB.Optional({
+            comment: "The last page where it occurs. If there is only one page, set this to the same as `first_page` oder remove it.",
+            type: DB.IncludeIdentifier(Page),
+        }),
+    }),
+});
+const Page = DB.Enum(import.meta.url, {
+    name: "Page",
+    values: () => ({
+        InsideCoverFront: DB.EnumCase({ type: null }),
+        InsideCoverBack: DB.EnumCase({ type: null }),
+        Numbered: DB.EnumCase({ type: DB.Integer() }),
+    }),
+});