@optolith/database-schema 0.42.1

package/lib/types/Ritual.js

@@ -0,0 +1,96 @@
+import * as DB from "tsondb/schema/dsl";
+import { OldParameter, SlowPerformanceParameters } from "./_ActivatableSkill.js";
+import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
+import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
+import { Enhancement } from "./_Enhancements.js";
+import { PropertyIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { SpellworkPrerequisites } from "./_Prerequisite.js";
+import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
+import { reversalis, SpellworkTraditions } from "./_Spellwork.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Ritual = DB.Entity(import.meta.url, {
+    name: "Ritual",
+    namePlural: "Rituals",
+    type: () => DB.Object({
+        check: DB.Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        check_penalty: DB.Optional({
+            comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+            type: DB.IncludeIdentifier(SkillCheckPenalty),
+        }),
+        parameters: DB.Required({
+            comment: "Measurable parameters of a ritual.",
+            type: DB.IncludeIdentifier(SlowPerformanceParameters),
+        }),
+        target: DB.Required({
+            comment: "The target category – the kind of creature or object – the skill affects.",
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
+        }),
+        property: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        traditions: DB.Required({
+            comment: "The tradition(s) the ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
+            type: DB.IncludeIdentifier(SpellworkTraditions),
+        }),
+        improvement_cost: DB.Required({
+            comment: "States which column is used to improve the skill.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites for the ritual.",
+            type: DB.IncludeIdentifier(SpellworkPrerequisites),
+        }),
+        reversalis,
+        src,
+        translations: NestedTranslationMap(DB.Required, "Ritual", DB.Object({
+            name: DB.Required({
+                comment: "The ritual’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+                type: DB.IncludeIdentifier(ActivatableSkillEffect),
+            }),
+            casting_time: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            cost: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            range: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            duration: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            target: DB.Optional({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+        enhancements: DB.Required({
+            type: DB.ChildEntities(Enhancement),
+        }),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Service.d.ts

@@ -0,0 +1,56 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Service: DB.Entity<"Service", {
+    availability: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ServiceAvailability", {
+        SummonedCreatures: DB.EnumCase<null>;
+        Monstrosities: DB.EnumCase<null>;
+    }, []>>>, true>;
+    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<"ServiceTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, true>;
+        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/Service.js

@@ -0,0 +1,45 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Service = DB.Entity(import.meta.url, {
+    name: "Service",
+    namePlural: "Services",
+    type: () => DB.Object({
+        availability: DB.Required({
+            comment: "Defines for which creature type(s) the service is available.",
+            type: DB.Array(DB.IncludeIdentifier(ServiceAvailability), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Service", DB.Object({
+            name: DB.Required({
+                comment: "The service’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The service’s description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const ServiceAvailability = DB.Enum(import.meta.url, {
+    name: "ServiceAvailability",
+    values: () => ({
+        SummonedCreatures: DB.EnumCase({ type: null }),
+        Monstrosities: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/SexPractice.d.ts

@@ -0,0 +1,51 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SexPractice: DB.Entity<"SexPractice", {
+    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<"SexPracticeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        rules: DB.MemberDecl<DB.String, true>;
+        duration: DB.MemberDecl<DB.String, true>;
+        prerequisites: DB.MemberDecl<DB.String, false>;
+        failed: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/SexPractice.js

@@ -0,0 +1,39 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { src } from "./source/_PublicationRef.js";
+export const SexPractice = DB.Entity(import.meta.url, {
+    name: "SexPractice",
+    namePlural: "SexPractices",
+    type: () => DB.Object({
+        src,
+        translations: NestedTranslationMap(DB.Required, "SexPractice", DB.Object({
+            name: DB.Required({
+                comment: "The sex practice’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            rules: DB.Required({
+                comment: "The rules of the sex practice.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            duration: DB.Required({
+                comment: "How long a round of this sex practice takes.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            prerequisites: DB.Optional({
+                comment: "Prerequisites of participants and environment. Do not specify if the sex practice has no prerequisites.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            failed: DB.Required({
+                comment: "Effects of a failed *Seduction* check.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Skill.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @main Skill
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const Skill: DB.Entity<"Skill", {
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    applications: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Applications", DB.Object<{
+        derived: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicationCategory", {
+            BlessedTraditions: DB.EnumCase<null>;
+            Diseases: DB.EnumCase<null>;
+            Regions: DB.EnumCase<null>;
+        }, []>>, false>;
+        explicit: DB.MemberDecl<DB.ChildEntities<DB.Entity<"SkillApplication", {
+            parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
+                name: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }, "parent">>, true>;
+    }>, []>>, true>;
+    encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EncumbranceInfluence", {
+        Yes: DB.EnumCase<null>;
+        No: DB.EnumCase<null>;
+        Maybe: DB.EnumCase<null>;
+    }, []>>, true>;
+    improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+        A: DB.EnumCase<null>;
+        B: DB.EnumCase<null>;
+        C: DB.EnumCase<null>;
+        D: DB.EnumCase<null>;
+    }, []>>, true>;
+    group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    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<"SkillTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        applications_input_label: DB.MemberDecl<DB.String, false>;
+        encumbrance_description: DB.MemberDecl<DB.String, false>;
+        tools: DB.MemberDecl<DB.String, false>;
+        quality: DB.MemberDecl<DB.String, true>;
+        failed: DB.MemberDecl<DB.String, true>;
+        critical: DB.MemberDecl<DB.String, true>;
+        botch: DB.MemberDecl<DB.String, true>;
+        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>;
+export declare const Applications: DB.TypeAlias<"Applications", DB.Object<{
+    derived: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicationCategory", {
+        BlessedTraditions: DB.EnumCase<null>;
+        Diseases: DB.EnumCase<null>;
+        Regions: DB.EnumCase<null>;
+    }, []>>, false>;
+    explicit: DB.MemberDecl<DB.ChildEntities<DB.Entity<"SkillApplication", {
+        parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
+            name: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }, "parent">>, true>;
+}>, []>;
+export declare const ApplicationCategory: DB.Enum<"ApplicationCategory", {
+    BlessedTraditions: DB.EnumCase<null>;
+    Diseases: DB.EnumCase<null>;
+    Regions: DB.EnumCase<null>;
+}, []>;
+export declare const SkillApplication: DB.Entity<"SkillApplication", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, "parent">;
+export declare const EncumbranceInfluence: DB.Enum<"EncumbranceInfluence", {
+    Yes: DB.EnumCase<null>;
+    No: DB.EnumCase<null>;
+    Maybe: DB.EnumCase<null>;
+}, []>;

package/lib/types/Skill.js

@@ -0,0 +1,139 @@
+/**
+ * @main Skill
+ */
+import * as DB from "tsondb/schema/dsl";
+import { SkillGroupIdentifier, SkillIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { SkillCheck } from "./_SkillCheck.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Skill = DB.Entity(import.meta.url, {
+    name: "Skill",
+    namePlural: "Skills",
+    type: () => DB.Object({
+        check: DB.Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        applications: DB.Required({
+            comment: "Lists applications for the skill, if any. This does not necessarily include all possible applications. There may also be new applications that could be purchased via certain advantages or special abilities.",
+            type: DB.IncludeIdentifier(Applications),
+        }),
+        encumbrance: DB.Required({
+            comment: "Indicates whether encumbrance gives a penalty for checks with the skill.",
+            type: DB.IncludeIdentifier(EncumbranceInfluence),
+        }),
+        improvement_cost: DB.Required({
+            comment: "States which column is used to improve the skill.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        group: DB.Required({
+            comment: "The skill group this skill belongs to.",
+            type: SkillGroupIdentifier(),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Skill", DB.Object({
+            name: DB.Required({
+                comment: "The skill’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            applications_input_label: DB.Optional({
+                comment: "If there are options available that can not be put into a selection list (like different cults), provide the label text for the input element here. Otherwise leave empty.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            encumbrance_description: DB.Optional({
+                comment: `The text listing the certain circumstances in which the encumbrance may count. This text must be used if \`encumbrance\` is set to \`"Maybe"\`, otherwise it is ignored if defined.`,
+                type: DB.String({ minLength: 1 }),
+            }),
+            tools: DB.Optional({
+                comment: "Mentions any tools from the equipment list that are necessary to employ the skill.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            quality: DB.Required({
+                comment: "Gives examples of the effects that various QL might provide.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            failed: DB.Required({
+                comment: "Lists examples of results for a failed check.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            critical: DB.Required({
+                comment: "Lists examples of results for a critical success.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            botch: DB.Required({
+                comment: "Lists examples of results for botches.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+export const Applications = DB.TypeAlias(import.meta.url, {
+    name: "Applications",
+    comment: "The skill’s applications",
+    type: () => DB.Object({
+        derived: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicationCategory),
+        }),
+        explicit: DB.Required({
+            comment: "A list of explicit applications.",
+            type: DB.ChildEntities(SkillApplication),
+        }),
+    }),
+});
+export const ApplicationCategory = DB.Enum(import.meta.url, {
+    name: "ApplicationCategory",
+    comment: "A category. All available entries from the specified category will be included as separate applications.",
+    values: () => ({
+        BlessedTraditions: DB.EnumCase({ type: null }),
+        Diseases: DB.EnumCase({ type: null }),
+        Regions: DB.EnumCase({ type: null }),
+    }),
+});
+export const SkillApplication = DB.Entity(import.meta.url, {
+    name: "SkillApplication",
+    namePlural: "SkillApplications",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The skill this application belongs to.",
+            type: SkillIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "SkillApplication", DB.Object({
+            name: DB.Required({
+                comment: "The skill application’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        [
+            { keyPath: "parent" },
+            {
+                entityMapKeyPath: "translations",
+                keyPathInEntityMap: "name",
+            },
+        ],
+    ],
+});
+export const EncumbranceInfluence = DB.Enum(import.meta.url, {
+    name: "EncumbranceInfluence",
+    comment: "Indicates whether encumbrance gives a penalty for checks with the skill.",
+    values: () => ({
+        Yes: DB.EnumCase({ type: null }),
+        No: DB.EnumCase({ type: null }),
+        Maybe: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/SkillGroup.d.ts

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SkillGroup: DB.Entity<"SkillGroup", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    color: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"GradientColor", {
+        Gaia: DB.EnumCase<null>;
+        LightHarvestGold: DB.EnumCase<null>;
+        OldRed: DB.EnumCase<null>;
+        SanMarino: DB.EnumCase<null>;
+        TribalTeal: DB.EnumCase<null>;
+        Verdigris: DB.EnumCase<null>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SkillGroupTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        longName: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/SkillGroup.js

@@ -0,0 +1,45 @@
+import * as DB from "tsondb/schema/dsl";
+import { GradientColor } from "./_Color.js";
+import { SkillCheck } from "./_SkillCheck.js";
+import { NestedTranslationMap } from "./Locale.js";
+export const SkillGroup = DB.Entity(import.meta.url, {
+    name: "SkillGroup",
+    namePlural: "SkillGroups",
+    type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the skill group in lists. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        check: DB.Required({
+            comment: "The skill group’s skill check attributes",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        color: DB.Required({
+            comment: "The display color of the skill group.",
+            type: DB.IncludeIdentifier(GradientColor),
+        }),
+        translations: NestedTranslationMap(DB.Required, "SkillGroup", DB.Object({
+            name: DB.Required({
+                comment: "The skill group’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            longName: DB.Required({
+                comment: "The skill group’s long name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    sortOrder: {
+        keyPath: "position",
+    },
+    uniqueConstraints: [
+        {
+            keyPath: "position",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/SkillModificationLevel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @main SkillModificationLevel
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const SkillModificationLevel: DB.Entity<"SkillModificationLevel", {
+    fast: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"FastSkillModificationLevelConfig", DB.Object<{
+        casting_time: DB.MemberDecl<DB.Integer, true>;
+        range: DB.MemberDecl<DB.Integer, true>;
+        cost: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>, true>;
+    slow: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SlowSkillModificationLevelConfig", DB.Object<{
+        casting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SlowSkillCastingTime", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SlowSkillCastingTimeUnit", {
+                Minutes: DB.EnumCase<null>;
+                Hours: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>, true>;
+        range: DB.MemberDecl<DB.Integer, true>;
+        cost: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SkillModificationLevelTranslation", {
+        fast: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LevelTypeConfigTranslation", DB.Object<{
+            range: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        slow: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LevelTypeConfigTranslation", DB.Object<{
+            range: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+    }>, false>;
+}, undefined>;
+export declare const SlowSkillCastingTimeUnit: DB.Enum<"SlowSkillCastingTimeUnit", {
+    Minutes: DB.EnumCase<null>;
+    Hours: DB.EnumCase<null>;
+}, []>;