optolith-database-schema 0.17.2 → 0.18.2

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

@@ -1,186 +1,120 @@
-/**
- * @main Armor
- */
-import { TypeConfig } from "../../../typeConfig.js";
-import { LocaleMap } from "../../_LocaleMap.js";
-import { NonEmptyMarkdown, NonEmptyString } from "../../_NonEmptyString.js";
-import { ArmorReference } from "../../_SimpleReferences.js";
-import { Errata } from "../../source/_Erratum.js";
-import { PublicationRefs } from "../../source/_PublicationRef.js";
-import { Complexity, Cost, Weight } from "./_Item.js";
-export type Armor = {
-    /**
-     * The cost in silverthalers.
-     */
-    cost: Cost;
-    /**
-     * The weight in kg.
-     */
-    weight: Weight;
-    /**
-     * The complexity of crafting the item.
-     */
-    complexity: Complexity;
-    /**
-     * The PRO value.
-     */
-    protection: Protection;
-    /**
-     * The ENC value.
-     */
-    encumbrance: Encumbrance;
-    /**
-     * Does the armor have additional penalties (MOV -1, INI -1)?
-     */
-    has_additional_penalties: HasAdditionalPenalties;
-    /**
-     * The armor type.
-     */
-    armor_type: ArmorType;
-    /**
-     * Specify if armor is only available for a specific hit zone.
-     */
-    hit_zone?: HitZone;
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<ArmorTranslation>;
-};
-/**
- * @minProperties 1
- */
-export type ArmorTranslation = {
-    /**
-     * The name of the item.
-     */
-    name: NonEmptyString;
-    /**
-     * An auxiliary name or label of the item, if available.
-     */
-    secondary_name?: NonEmptyString;
-    /**
-     * Note text.
-     */
-    note?: NonEmptyMarkdown;
-    /**
-     * Special rules text.
-     */
-    rules?: NonEmptyMarkdown;
-    /**
-     * The armor advantage text.
-     */
-    advantage?: NonEmptyMarkdown;
-    /**
-     * The armor disadvantage text.
-     */
-    disadvantage?: NonEmptyMarkdown;
-    errata?: Errata;
-};
-export type SecondaryArmor = {
-    /**
-     * The PRO value.
-     */
-    protection: Protection;
-    /**
-     * The ENC value.
-     */
-    encumbrance: Encumbrance;
-    /**
-     * Does the armor have additional penalties (MOV -1, INI -1)?
-     */
-    has_additional_penalties: HasAdditionalPenalties;
-    /**
-     * The armor type.
-     */
-    armor_type: ArmorType;
-    /**
-     * Specify if armor is only available for a specific hit zone.
-     */
-    hit_zone?: HitZone;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<SecondaryArmorTranslation>;
-};
-/**
- * @minProperties 1
- */
-export type SecondaryArmorTranslation = {
-    /**
-     * The armor advantage text.
-     */
-    advantage?: NonEmptyMarkdown;
-    /**
-     * The armor disadvantage text.
-     */
-    disadvantage?: NonEmptyMarkdown;
-};
-/**
- * The PRO value.
- * @integer
- * @minimum 0
- */
-export type Protection = number;
-/**
- * The ENC value.
- * @integer
- * @minimum 0
- */
-export type Encumbrance = number;
-/**
- * Does the armor have additional penalties (MOV -1, INI -1)?
- */
-export type HasAdditionalPenalties = boolean;
-/**
- * The armor type.
- * @title Armor Type
- */
-export type ArmorType = {
-    /**
-     * The armor type's identifier.
-     * @integer
-     * @minimum 1
-     * @maximum 10
-     */
-    id: number;
-};
-/**
- * Specify if armor is only available for a specific hit zone.
- * @title Hit Zone
- */
-export type HitZone = {
-    tag: "Head";
-    head: HeadHitZone;
-} | {
-    tag: "Torso";
-    torso: {};
-} | {
-    tag: "Arms";
-    arms: {};
-} | {
-    tag: "Legs";
-    legs: {};
-};
-export type HeadHitZone = {
-    /**
-     * In some cases, multiple armors for the same hit zone can be combined.
-     * They're listed at the item that can be combined with others.
-     */
-    combination_possibilities?: HeadHitZoneCombinationPossibilities;
-};
-export type HeadHitZoneCombinationPossibilities = {
-    /**
-     * A list of armors that can be combined with this armor.
-     * @minItems 1
-     */
-    armors: ArmorReference[];
-    /**
-     * The PRO value that is added to the PRO value of the other armor instead
-     * of adding the normale PRO value.
-     * @integer
-     * @minimum 0
-     */
-    protection?: number;
-};
-export declare const config: TypeConfig<Armor, number, "Armor">;
+import { Array, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const Armor: Entity<"Armor", {
+    cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Cost", {
+        Free: EnumCase<null>;
+        Various: EnumCase<null>;
+        Invaluable: EnumCase<null>;
+        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
+            value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCostTranslation", {
+                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, false>;
+        }>, []>>>;
+        Range: EnumCase<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
+            from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CostRangeTranslation", {
+                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    weight: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Weight", import("tsondb/schema/def").FloatType, []>>, true>;
+    complexity: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Complexity", {
+        Primitive: EnumCase<null>;
+        Simple: EnumCase<null>;
+        Complex: EnumCase<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", Object<{
+            ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    protection: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Protection", Integer, []>>, true>;
+    encumbrance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Encumbrance", Integer, []>>, true>;
+    has_additional_penalties: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HasAdditionalPenalties", Boolean, []>>, true>;
+    armor_type: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    hit_zone: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"HitZone", {
+        Head: EnumCase<IncludeIdentifier<[], TypeAlias<"HeadHitZone", Object<{
+            combination_possibilities: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HeadHitZoneCombinationPossibilities", Object<{
+                armors: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+                protection: import("tsondb/schema/def").MemberDecl<Integer, false>;
+            }>, []>>, false>;
+        }>, []>>>;
+        Torso: EnumCase<null>;
+        Arms: EnumCase<null>;
+        Legs: EnumCase<null>;
+    }, []>>, 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<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<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<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: EnumCase<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<"ArmorTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        secondary_name: import("tsondb/schema/def").MemberDecl<String, false>;
+        note: import("tsondb/schema/def").MemberDecl<String, false>;
+        rules: import("tsondb/schema/def").MemberDecl<String, false>;
+        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;
+export declare const SecondaryArmor: TypeAlias<"SecondaryArmor", Object<{
+    protection: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Protection", Integer, []>>, true>;
+    encumbrance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Encumbrance", Integer, []>>, true>;
+    has_additional_penalties: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HasAdditionalPenalties", Boolean, []>>, true>;
+    armor_type: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    hit_zone: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"HitZone", {
+        Head: EnumCase<IncludeIdentifier<[], TypeAlias<"HeadHitZone", Object<{
+            combination_possibilities: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HeadHitZoneCombinationPossibilities", Object<{
+                armors: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+                protection: import("tsondb/schema/def").MemberDecl<Integer, false>;
+            }>, []>>, false>;
+        }>, []>>>;
+        Torso: EnumCase<null>;
+        Arms: EnumCase<null>;
+        Legs: EnumCase<null>;
+    }, []>>, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SecondaryArmorTranslation", {
+        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, false>;
+}>, []>;
+export declare const Protection: TypeAlias<"Protection", Integer, []>;
+export declare const Encumbrance: TypeAlias<"Encumbrance", Integer, []>;
+export declare const HasAdditionalPenalties: TypeAlias<"HasAdditionalPenalties", Boolean, []>;

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

@@ -1,14 +1,157 @@
-/**
- * @main Armor
- */
-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, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { ArmorIdentifier, ArmorTypeIdentifier } from "../../_Identifier.js";
+import { NestedLocaleMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity, Cost, Weight } from "./_Item.js";
+export const Armor = Entity(import.meta.url, {
     name: "Armor",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Armor"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Armor",
+    type: () => Object({
+        cost: Required({
+            comment: "The cost in silverthalers.",
+            type: IncludeIdentifier(Cost),
+        }),
+        weight: Required({
+            comment: "The weight in kg.",
+            type: IncludeIdentifier(Weight),
+        }),
+        complexity: Optional({
+            comment: "The complexity of crafting the item.",
+            type: IncludeIdentifier(Complexity),
+        }),
+        protection: Required({
+            comment: "The PRO value.",
+            type: IncludeIdentifier(Protection),
+        }),
+        encumbrance: Required({
+            comment: "The ENC value.",
+            type: IncludeIdentifier(Encumbrance),
+        }),
+        has_additional_penalties: Required({
+            comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
+            type: IncludeIdentifier(HasAdditionalPenalties),
+        }),
+        armor_type: Required({
+            comment: "The armor type..",
+            type: ArmorTypeIdentifier(),
+        }),
+        hit_zone: Optional({
+            comment: "Specify if armor is only available for a specific hit zone.",
+            type: IncludeIdentifier(HitZone),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "ArmorTranslation", Object({
+            name: Required({
+                comment: "The item’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            secondary_name: Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: String({ minLength: 1 }),
+            }),
+            note: Optional({
+                comment: "Note text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            rules: Optional({
+                comment: "Special rules text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            advantage: Optional({
+                comment: "The armor advantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            disadvantage: Optional({
+                comment: "The armor disadvantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+export const SecondaryArmor = TypeAlias(import.meta.url, {
+    name: "SecondaryArmor",
+    type: () => Object({
+        protection: Required({
+            comment: "The PRO value.",
+            type: IncludeIdentifier(Protection),
+        }),
+        encumbrance: Required({
+            comment: "The ENC value.",
+            type: IncludeIdentifier(Encumbrance),
+        }),
+        has_additional_penalties: Required({
+            comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
+            type: IncludeIdentifier(HasAdditionalPenalties),
+        }),
+        armor_type: Required({
+            comment: "The armor type..",
+            type: ArmorTypeIdentifier(),
+        }),
+        hit_zone: Optional({
+            comment: "Specify if armor is only available for a specific hit zone.",
+            type: IncludeIdentifier(HitZone),
+        }),
+        translations: NestedLocaleMap(Optional, "SecondaryArmorTranslation", Object({
+            advantage: Optional({
+                comment: "The armor advantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            disadvantage: Optional({
+                comment: "The armor disadvantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+export const Protection = TypeAlias(import.meta.url, {
+    name: "Protection",
+    comment: "The PRO value.",
+    type: () => Integer({ minimum: 0 }),
+});
+export const Encumbrance = TypeAlias(import.meta.url, {
+    name: "Encumbrance",
+    comment: "The ENC value.",
+    type: () => Integer({ minimum: 0 }),
+});
+export const HasAdditionalPenalties = TypeAlias(import.meta.url, {
+    name: "HasAdditionalPenalties",
+    comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
+    type: () => Boolean(),
+});
+const HitZone = Enum(import.meta.url, {
+    name: "HitZone",
+    comment: "Specify if armor is only available for a specific hit zone.",
+    values: () => ({
+        Head: EnumCase({ type: IncludeIdentifier(HeadHitZone) }),
+        Torso: EnumCase({ type: null }),
+        Arms: EnumCase({ type: null }),
+        Legs: EnumCase({ type: null }),
+    }),
+});
+const HeadHitZone = TypeAlias(import.meta.url, {
+    name: "HeadHitZone",
+    type: () => Object({
+        combination_possibilities: Optional({
+            comment: "In some cases, multiple armors for the same hit zone can be combined. They're listed at the item that can be combined with others.",
+            type: IncludeIdentifier(HeadHitZoneCombinationPossibilities),
+        }),
+    }),
+});
+const HeadHitZoneCombinationPossibilities = TypeAlias(import.meta.url, {
+    name: "HeadHitZoneCombinationPossibilities",
+    type: () => Object({
+        armors: Required({
+            comment: "A list of armors that can be combined with this armor.",
+            type: Array(ArmorIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        protection: Optional({
+            comment: "The PRO value that is added to the PRO value of the other armor instead of adding the normale PRO value.",
+            type: Integer({ minimum: 0 }),
+        }),
+    }),
+});