optolith-database-schema 0.17.2 → 0.18.1

package/lib/types/_Prerequisite.js

@@ -1,4 +1,139 @@
 /**
  * @title Prerequisites
  */
-export {};
+import { Array, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { DisplayOption } from "./prerequisites/DisplayOption.js";
+import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, SpellworkPrerequisiteGroup, } from "./prerequisites/PrerequisiteGroups.js";
+const PrerequisiteGroup = GenTypeAlias(import.meta.url, {
+    name: "PrerequisiteGroup",
+    comment: "A prerequisite group has no influence on validation logic. It serves as a single unit for displaying purposes, where the source uses a prerequisites item that cannot be represented as a single prerequisite.",
+    parameters: [Param("T")],
+    type: T => Object({
+        list: Required({
+            type: Array(TypeArgument(T), { minItems: 2 }),
+        }),
+        translations: NestedLocaleMap(Required, "PrerequisiteGroupTranslation", Object({
+            text: Required({
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+const PrerequisitesDisjunction = GenTypeAlias(import.meta.url, {
+    name: "PrerequisitesDisjunction",
+    parameters: [Param("T")],
+    type: T => Object({
+        list: Required({
+            type: Array(TypeArgument(T), { minItems: 2 }),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const PrerequisitesElement = GenEnum(import.meta.url, {
+    name: "PrerequisitesElement",
+    parameters: [Param("T")],
+    values: T => ({
+        Single: EnumCase({ type: TypeArgument(T) }),
+        Disjunction: EnumCase({
+            type: GenIncludeIdentifier(PrerequisitesDisjunction, [TypeArgument(T)]),
+        }),
+        Group: EnumCase({
+            type: GenIncludeIdentifier(PrerequisiteGroup, [TypeArgument(T)]),
+        }),
+    }),
+});
+const PlainPrerequisites = GenTypeAlias(import.meta.url, {
+    name: "PlainPrerequisites",
+    parameters: [Param("T")],
+    type: T => Array(GenIncludeIdentifier(PrerequisitesElement, [TypeArgument(T)]), { minItems: 1 }),
+});
+const PrerequisiteForLevel = GenTypeAlias(import.meta.url, {
+    name: "PrerequisiteForLevel",
+    parameters: [Param("T")],
+    type: T => Object({
+        level: Required({
+            comment: "The level to which the prerequisite applies.",
+            type: Integer({ minimum: 1 }),
+        }),
+        prerequisite: Required({
+            comment: "The prerequisite.",
+            type: GenIncludeIdentifier(PrerequisitesElement, [TypeArgument(T)]),
+        }),
+    }),
+});
+const PrerequisitesForLevels = GenTypeAlias(import.meta.url, {
+    name: "PrerequisitesForLevels",
+    parameters: [Param("T")],
+    type: T => Array(GenIncludeIdentifier(PrerequisiteForLevel, [TypeArgument(T)]), {
+        minItems: 1,
+    }),
+});
+export const DerivedCharacteristicPrerequisites = TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [
+        IncludeIdentifier(DerivedCharacteristicPrerequisiteGroup),
+    ]),
+});
+export const PublicationPrerequisites = TypeAlias(import.meta.url, {
+    name: "PublicationPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(PublicationPrerequisiteGroup)]),
+});
+export const PlainGeneralPrerequisites = TypeAlias(import.meta.url, {
+    name: "PlainGeneralPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(GeneralPrerequisiteGroup)]),
+});
+export const GeneralPrerequisites = TypeAlias(import.meta.url, {
+    name: "GeneralPrerequisites",
+    type: () => GenIncludeIdentifier(PrerequisitesForLevels, [IncludeIdentifier(GeneralPrerequisiteGroup)]),
+});
+export const ProfessionPrerequisites = TypeAlias(import.meta.url, {
+    name: "ProfessionPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(ProfessionPrerequisiteGroup)]),
+});
+export const AdvantageDisadvantagePrerequisites = TypeAlias(import.meta.url, {
+    name: "AdvantageDisadvantagePrerequisites",
+    type: () => GenIncludeIdentifier(PrerequisitesForLevels, [
+        IncludeIdentifier(AdvantageDisadvantagePrerequisiteGroup),
+    ]),
+});
+export const ArcaneTraditionPrerequisites = TypeAlias(import.meta.url, {
+    name: "ArcaneTraditionPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(ArcaneTraditionPrerequisiteGroup)]),
+});
+export const PersonalityTraitPrerequisites = TypeAlias(import.meta.url, {
+    name: "PersonalityTraitPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [
+        IncludeIdentifier(PersonalityTraitPrerequisiteGroup),
+    ]),
+});
+export const SpellworkPrerequisites = TypeAlias(import.meta.url, {
+    name: "SpellworkPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(SpellworkPrerequisiteGroup)]),
+});
+export const LiturgyPrerequisites = TypeAlias(import.meta.url, {
+    name: "LiturgyPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(LiturgyPrerequisiteGroup)]),
+});
+export const InfluencePrerequisites = TypeAlias(import.meta.url, {
+    name: "InfluencePrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(InfluencePrerequisiteGroup)]),
+});
+export const LanguagePrerequisites = TypeAlias(import.meta.url, {
+    name: "LanguagePrerequisites",
+    type: () => GenIncludeIdentifier(PrerequisitesForLevels, [IncludeIdentifier(LanguagePrerequisiteGroup)]),
+});
+export const AnimistPowerPrerequisites = TypeAlias(import.meta.url, {
+    name: "AnimistPowerPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(AnimistPowerPrerequisiteGroup)]),
+});
+export const GeodeRitualPrerequisites = TypeAlias(import.meta.url, {
+    name: "GeodeRitualPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(GeodeRitualPrerequisiteGroup)]),
+});
+export const EnhancementPrerequisites = TypeAlias(import.meta.url, {
+    name: "EnhancementPrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(EnhancementPrerequisiteGroup)]),
+});

package/lib/types/_ResponsiveText.d.ts

@@ -1,54 +1,13 @@
-import { NonEmptyString } from "./_NonEmptyString.js";
-/**
- * A text from the source that can be also displayed in small areas using a
- * compressed version.
- */
-export type ResponsiveText = {
-    /**
-     * The full text from the source.
-     */
-    full: NonEmptyString;
-    /**
-     * A compressed text for use in small areas (e.g. on character sheet).
-     */
-    compressed: NonEmptyString;
-};
-/**
- * A text from the source that can be also displayed in small areas using a
- * compressed version. It is used as a replacement for a generated text while
- * the generated text is still provided and should be used.
- */
-export type ResponsiveTextReplace = {
-    /**
-     * The full replacement string. It must contain `$1`, which is going to be
-     * replaced with the generated string, so additional information can be
-     * provided without duplicating concrete numeric values.
-     * @minLength 1
-     * @pattern \$1
-     */
-    full: string;
-    /**
-     * A compressed replacement string for use in small areas (e.g. on character
-     * sheet). It must contain `$1`, which is going to be replaced with the
-     * generated string, so additional information can be provided without
-     * duplicating concrete numeric values.
-     * @minLength 1
-     * @pattern \$1
-     */
-    compressed: string;
-};
-/**
- * A text from the source that can be also displayed in small areas using a
- * compressed version, if available.
- */
-export type ResponsiveTextOptional = {
-    /**
-     * The full text from the source.
-     */
-    full: NonEmptyString;
-    /**
-     * A compressed text for use in small areas (e.g. on character sheet). If this
-     * is not present, it should not appear in those areas.
-     */
-    compressed?: NonEmptyString;
-};
+import { Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const ResponsiveText: TypeAlias<"ResponsiveText", Object<{
+    full: import("tsondb/schema/def").MemberDecl<String, true>;
+    compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+}>, []>;
+export declare const ResponsiveTextReplace: TypeAlias<"ResponsiveTextReplace", Object<{
+    full: import("tsondb/schema/def").MemberDecl<String, true>;
+    compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+}>, []>;
+export declare const ResponsiveTextOptional: TypeAlias<"ResponsiveTextOptional", Object<{
+    full: import("tsondb/schema/def").MemberDecl<String, true>;
+    compressed: import("tsondb/schema/def").MemberDecl<String, false>;
+}>, []>;

package/lib/types/_ResponsiveText.js

@@ -1 +1,37 @@
-export {};
+import { Object, Optional, Required, String, TypeAlias } from "tsondb/schema/def";
+export const ResponsiveText = TypeAlias(import.meta.url, {
+    name: "ResponsiveText",
+    comment: "A text from the source that can be also displayed in small areas using a compressed version.",
+    type: () => Object({
+        full: Required({ comment: "The full text from the source.", type: String({ minLength: 1 }) }),
+        compressed: Required({
+            comment: "A compressed text for use in small areas (e.g. on character sheet).",
+            type: String({ minLength: 1 }),
+        }),
+    }),
+});
+export const ResponsiveTextReplace = TypeAlias(import.meta.url, {
+    name: "ResponsiveTextReplace",
+    comment: "A text from the source that can be also displayed in small areas using a compressed version. It is used as a replacement for a generated text while the generated text is still provided and should be used.",
+    type: () => Object({
+        full: Required({
+            comment: "The full replacement string. It must contain `$1`, which is going to be replaced with the generated string, so additional information can be provided without duplicating concrete numeric values.",
+            type: String({ minLength: 1, pattern: /\$1/ }),
+        }),
+        compressed: Required({
+            comment: "A compressed replacement string for use in small areas (e.g. on character sheet). It must contain `$1`, which is going to be replaced with the generated string, so additional information can be provided without duplicating concrete numeric values.",
+            type: String({ minLength: 1, pattern: /\$1/ }),
+        }),
+    }),
+});
+export const ResponsiveTextOptional = TypeAlias(import.meta.url, {
+    name: "ResponsiveTextOptional",
+    comment: "A text from the source that can be also displayed in small areas using a compressed version, if available.",
+    type: () => Object({
+        full: Required({ comment: "The full text from the source.", type: String({ minLength: 1 }) }),
+        compressed: Optional({
+            comment: "A compressed text for use in small areas (e.g. on character sheet). If this is not present, it should not appear in those areas.",
+            type: String({ minLength: 1 }),
+        }),
+    }),
+});

package/lib/types/_Sex.d.ts

@@ -1,7 +1,5 @@
-/**
- * @main BinarySex
- */
-/**
- * @title Binary Sex
- */
-export type BinarySex = "Male" | "Female";
+import { Enum, EnumCase } from "tsondb/schema/def";
+export declare const BinarySex: Enum<"BinarySex", {
+    Male: EnumCase<null>;
+    Female: EnumCase<null>;
+}, []>;

package/lib/types/_Sex.js

@@ -1,4 +1,8 @@
-/**
- * @main BinarySex
- */
-export {};
+import { Enum, EnumCase } from "tsondb/schema/def";
+export const BinarySex = Enum(import.meta.url, {
+    name: "BinarySex",
+    values: () => ({
+        Male: EnumCase({ type: null }),
+        Female: EnumCase({ type: null }),
+    }),
+});

package/lib/types/_SkillCheck.d.ts

@@ -1,15 +1,10 @@
-import { AttributeReference } from "./_SimpleReferences.js";
-/**
- * The attributes' identifiers of the skill check.
- * @title Skill Check
- */
-export type SkillCheck = [
-    AttributeReference,
-    AttributeReference,
-    AttributeReference
-];
-/**
- * A specific value that represents a penalty for the associated skill check.
- * @title Skill Check Penalty
- */
-export type SkillCheckPenalty = "Spirit" | "HalfOfSpirit" | "Toughness" | "HigherOfSpiritAndToughness" | "SummoningDifficulty" | "CreationDifficulty";
+import { Array, Enum, EnumCase, TypeAlias } from "tsondb/schema/def";
+export declare const SkillCheck: TypeAlias<"SkillCheck", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>;
+export declare const SkillCheckPenalty: Enum<"SkillCheckPenalty", {
+    Spirit: EnumCase<null>;
+    HalfOfSpirit: EnumCase<null>;
+    Toughness: EnumCase<null>;
+    HigherOfSpiritAndToughness: EnumCase<null>;
+    SummoningDifficulty: EnumCase<null>;
+    CreationDifficulty: EnumCase<null>;
+}, []>;

package/lib/types/_SkillCheck.js

@@ -1 +1,34 @@
-export {};
+import { Array, Enum, EnumCase, TypeAlias } from "tsondb/schema/def";
+import { AttributeIdentifier } from "./_Identifier.js";
+export const SkillCheck = TypeAlias(import.meta.url, {
+    name: "SkillCheck",
+    comment: "The attributes’ identifiers of the skill check.",
+    type: () => Array(AttributeIdentifier(), {
+        minItems: 3,
+        maxItems: 3,
+    }),
+});
+export const SkillCheckPenalty = Enum(import.meta.url, {
+    name: "SkillCheckPenalty",
+    comment: "A specific value that represents a penalty for the associated skill check.",
+    values: () => ({
+        Spirit: EnumCase({
+            type: null,
+        }),
+        HalfOfSpirit: EnumCase({
+            type: null,
+        }),
+        Toughness: EnumCase({
+            type: null,
+        }),
+        HigherOfSpiritAndToughness: EnumCase({
+            type: null,
+        }),
+        SummoningDifficulty: EnumCase({
+            type: null,
+        }),
+        CreationDifficulty: EnumCase({
+            type: null,
+        }),
+    }),
+});

package/lib/types/_Spellwork.d.ts

@@ -1,18 +1,5 @@
-import { MagicalTraditionIdentifier } from "./_Identifier.js";
-/**
- * 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.
- */
-export type Traditions = {
-    tag: "General";
-    general: {};
-} | {
-    tag: "Specific";
-    specific: SpecificTraditions;
-};
-/**
- * A list of specific traditions.
- * @minItems 1
- */
-export type SpecificTraditions = MagicalTraditionIdentifier[];
+import { Array, Enum, EnumCase } from "tsondb/schema/def";
+export declare const SpellworkTraditions: Enum<"SpellworkTraditions", {
+    General: EnumCase<null>;
+    Specific: EnumCase<Array<import("tsondb/schema/def").ReferenceIdentifierType>>;
+}, []>;

package/lib/types/_Spellwork.js

@@ -1 +1,13 @@
-export {};
+import { Array, Enum, EnumCase } from "tsondb/schema/def";
+import { MagicalTraditionIdentifier } from "./_Identifier.js";
+export const SpellworkTraditions = Enum(import.meta.url, {
+    name: "SpellworkTraditions",
+    comment: "The tradition(s) the spell or ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
+    values: () => ({
+        General: EnumCase({ type: null }),
+        Specific: EnumCase({
+            comment: "A list of specific traditions.",
+            type: Array(MagicalTraditionIdentifier(), { minItems: 1 }),
+        }),
+    }),
+});

package/lib/types/equipment/EquipmentPackage.d.ts

@@ -1,51 +1,80 @@
-/**
- * @main EquipmentPackage
- */
-import { TypeConfig } from "../../typeConfig.js";
-import { EquipmentIdentifier } from "../_IdentifierGroup.js";
-import { LocaleMap } from "../_LocaleMap.js";
-import { NonEmptyString } from "../_NonEmptyString.js";
-import { PublicationRefs } from "../source/_PublicationRef.js";
-/**
- * @title Equipment Package
- */
-export type EquipmentPackage = {
-    /**
-     * The equipment package's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    /**
-     * All items in the package. You have to provide the item (template)
-     * identifier and you can optionally provide the number of how often an item
-     * is included in the package.
-     * @minItems 2
-     */
-    items: EquipmentPackageItem[];
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<EquipmentPackageTranslation>;
-};
-export type EquipmentPackageItem = {
-    /**
-     * The item's identifier.
-     */
-    id: EquipmentIdentifier;
-    /**
-     * The number of how often the item is included in the package.
-     * @integer
-     * @minimum 2
-     * @default 1
-     */
-    number?: number;
-};
-export type EquipmentPackageTranslation = {
-    /**
-     * The name of the equipment package.
-     */
-    name: NonEmptyString;
-};
-export declare const config: TypeConfig<EquipmentPackage, EquipmentPackage["id"], "EquipmentPackage">;
+import { Array, Entity, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const EquipmentPackage: Entity<"EquipmentPackage", {
+    items: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"EquipmentPackageItem", Object<{
+        id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"EquipmentIdentifier", {
+            Ammunition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Animal: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AnimalCare: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Armor: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            BandageOrRemedy: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Book: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CeremonialItem: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Clothes: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Container: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Elixir: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            EquipmentOfBlessedOnes: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            GemOrPreciousStone: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            IlluminationLightSource: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            IlluminationRefillsOrSupplies: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Jewelry: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Liebesspielzeug: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            LuxuryGood: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MagicalArtifact: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MusicalInstrument: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            OrienteeringAid: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Poison: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            RopeOrChain: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Stationary: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ThievesTool: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ToolOfTheTrade: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            TravelGearOrTool: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Vehicle: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Weapon: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+            WeaponAccessory: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        }, []>>, true>;
+        number: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    }>, []>>>, false>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
+                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"EquipmentPackageTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/equipment/EquipmentPackage.js

@@ -1,14 +1,35 @@
-/**
- * @main EquipmentPackage
- */
-import { todo } from "../../validation/builders/integrity.js";
-import { validateEntityFileName } from "../../validation/builders/naming.js";
-import { createSchemaValidator } from "../../validation/builders/schema.js";
-import { getFilenamePrefixAsNumericId } from "../../validation/filename.js";
-export const config = {
+import { Array, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { EquipmentIdentifier } from "../_IdentifierGroup.js";
+import { NestedLocaleMap } from "../Locale.js";
+import { src } from "../source/_PublicationRef.js";
+export const EquipmentPackage = Entity(import.meta.url, {
     name: "EquipmentPackage",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("EquipmentPackage"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "EquipmentPackages",
+    type: () => Object({
+        items: Optional({
+            comment: "All items in the package. You have to provide the item (template) identifier and you can optionally provide the number of how often an item is included in the package.",
+            type: Array(IncludeIdentifier(EquipmentPackageItem), { minItems: 2 }),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "EquipmentPackageTranslation", Object({
+            name: Required({
+                comment: "The equipment package’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const EquipmentPackageItem = TypeAlias(import.meta.url, {
+    name: "EquipmentPackageItem",
+    type: () => Object({
+        id: Required({
+            comment: "The item’s identifier.",
+            type: IncludeIdentifier(EquipmentIdentifier),
+        }),
+        number: Optional({
+            comment: "The number of how often the item is included in the package.",
+            type: Integer({ minimum: 2 }),
+        }),
+    }),
+});