optolith-database-schema 0.2.2 → 0.3.0

package/lib/types/Culture.d.ts

@@ -4,7 +4,10 @@
 import { Errata } from "./source/_Erratum.js";
 import { PublicationRefs } from "./source/_PublicationRef.js";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
+import { LocaleMap } from "./_LocaleMap.js";
+import { NonEmptyString } from "./_NonEmptyString.js";
 import { BinarySex } from "./_Sex.js";
+import { LanguageReference, ProfessionReference, ProfessionVariantReference, ScriptReference, SkillReference, SocialStatusReference } from "./_SimpleReferences.js";
 /**
  * @title Culture
  */
@@ -19,13 +22,13 @@ export declare type Culture = {
      * A list of native languages (usually it is only one).
      * @minItems 1
      */
-    language: Language[];
+    language: LanguageReference[];
     /**
      * A list of native scripts (usually it is only one). If the culture does not
      * use any script, leave this field empty.
      * @minItems 1
      */
-    script?: Script[];
+    script?: ScriptReference[];
     /**
      * If the area knowledge has a fixed value or can be adjusted.
      */
@@ -34,14 +37,14 @@ export declare type Culture = {
      * A list of possible social status in the respective culture.
      * @minItems 1
      */
-    social_status: SocialStatus[];
+    social_status: SocialStatusReference[];
     /**
      * A list of professions that are typical for the culture, as well as
      * professions that are rarely practiced or encountered in the culture. The
      * list is either defined by group (as multiple lists) or plain (as a single
      * list).
      */
-    common_professions: CommonProfessions.Config;
+    common_professions: CommonProfessions;
     /**
      * A list of common advantages.
      * @minItems 1
@@ -80,291 +83,174 @@ export declare type Culture = {
     src: PublicationRefs;
     /**
      * All translations for the entry, identified by IETF language tag (BCP47).
-     * @minProperties 1
-     */
-    translations: {
-        /**
-         * @patternProperties ^[a-z]{2}-[A-Z]{2}$
-         */
-        [localeId: string]: Translation;
-    };
+     */
+    translations: LocaleMap<CultureTranslation>;
 };
-declare type Language = {
+/**
+ * If the area knowledge has a fixed value or can be adjusted.
+ */
+export declare type AreaKnowledge = {
     /**
-     * The language's identifier.
-     * @integer
-     * @minimum 1
+     * `true` if the area knowledge has a fixed value, `false` if it can be
+     * adjusted.
      */
-    id: number;
+    is_fixed: boolean;
+};
+/**
+ * The "weight" difference compared to other professions or profession variants.
+ * Some professions or profession variants are simply more common (Mostly), but
+ * sometimes only specific elements are used (Only).
+ */
+export declare type Weight = {
+    tag: "Mostly";
+} | {
+    tag: "Only";
 };
-declare type Script = {
+/**
+ * Some professions or profession variants are more common than others. There
+ * may be cultures where some professions or profession variants are not
+ * represented at all.
+ */
+export declare type Weighted<ProfessionOrVariant> = {
     /**
-     * The script's identifier.
-     * @integer
-     * @minimum 1
+     * The list of more common professions or profession variants.
+     * @minItems 1
      */
-    id: number;
+    elements: ProfessionOrVariant[];
+    /**
+     * The "weight" difference compared to other professions or profession
+     * variants. Some professions or profession variants are simply more common
+     * (Mostly), but sometimes only specific elements are used (Only).
+     */
+    weight: Weight;
 };
 /**
- * If the area knowledge has a fixed value or can be adjusted.
+ * This defines how the list of constraints should be offset against the
+ * list of all mundane professions: Either only the professions are kept
+ * that intersect with the constraints (include) or only the professions
+ * are kept that are different from the constraints (exclude).
  */
-declare type AreaKnowledge = {
-    tag: "Fixed";
+export declare type CommonProfessionConstraintsOperation = {
+    tag: "Intersection";
 } | {
-    tag: "Adjustable";
+    tag: "Difference";
 };
-declare type SocialStatus = {
+/**
+ * A list of professions. The filter specifies how the list is applied to
+ * all mundane professions.
+ */
+export declare type CommonProfessionConstraints<Constraint> = {
+    /**
+     * The list of constraints.
+     * @minItems 1
+     */
+    constraints: Constraint[];
+    /**
+     * This defines how the list of constraints should be offset against the
+     * list of all mundane professions: Either only the professions are kept
+     * that intersect with the constraints (include) or only the professions
+     * are kept that are different from the constraints (exclude).
+     */
+    operation: CommonProfessionConstraintsOperation;
+};
+/**
+ * Some professions may be found in a culture, but are not that common.
+ */
+export declare type Rarity = {
+    tag: "Rare";
+} | {
+    tag: "VeryRare";
+};
+export declare type ProfessionConstraint = {
     /**
-     * The social status's identifier.
+     * The profession's identifier.
      * @integer
      * @minimum 1
      */
     id: number;
+    /**
+     * Some profession variants are more common than others. There may be
+     * cultures where some variants are not represented at all.
+     */
+    weighted_variants?: Weighted<ProfessionVariantReference>;
+    /**
+     * Some professions may be found in a culture, but are not that
+     * common.
+     */
+    rarity?: Rarity;
 };
 /**
- * @title Common Professions
+ * Some professions may be found in a culture, but are not that common.
  */
-declare namespace CommonProfessions {
-    type Profession = {
-        /**
-         * The profession's identifier.
-         * @integer
-         * @minimum 1
-         */
-        id: number;
-    };
-    type ProfessionVariant = {
-        /**
-         * The profession variant's identifier.
-         * @integer
-         * @minimum 1
-         */
-        id: number;
-    };
-    namespace Plain {
-        type Constraint = {
-            tag: "Profession";
-            /**
-             * The profession's identifier.
-             * @integer
-             * @minimum 1
-             */
-            id: number;
-        };
-        /**
-         * A plain list of professions.
-         */
-        type T = {
-            tag: "Plain";
-            /**
-             * The list of professions.
-             * @minItems 1
-             */
-            constraints: Constraint[];
-        };
-    }
-    namespace Grouped {
-        namespace Constraints {
-            /**
-             * Some profession variants are more common than others. There may be
-             * cultures where some variants are not represented at all.
-             */
-            type WeightedVariants = {
-                /**
-                 * The list of more common variants.
-                 * @minItems 1
-                 */
-                variants: ProfessionVariant[];
-                /**
-                 * The "weight" difference compared to other variants. Some variants are
-                 * simply more common (Mostly), but sometimes only specific variants are
-                 * used (Only).
-                 */
-                weight: Weight;
-            };
-            type Profession = {
-                tag: "Profession";
-                /**
-                 * The profession's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-                /**
-                 * Some profession variants are more common than others. There may be
-                 * cultures where some variants are not represented at all.
-                 */
-                weighted_variants?: WeightedVariants;
-                /**
-                 * Some professions may be found in a culture, but are not that
-                 * common.
-                 */
-                rarity?: Rarity;
-            };
-        }
-        /**
-         * The "weight" difference compared to other variants. Some variants are
-         * simply more common (Mostly), but sometimes only specific variants are
-         * used (Only).
-         */
-        type Weight = {
-            tag: "Mostly";
-        } | {
-            tag: "Only";
-        };
-        /**
-         * Some professions may be found in a culture, but are not that common.
-         */
-        type Rarity = {
-            tag: "Rare";
-        } | {
-            tag: "VeryRare";
-        };
-        namespace Mundane {
-            /**
-             * Some professions may be found in a culture, but are not that common.
-             */
-            type ProfessionSubgroup = {
-                tag: "Profane";
-            } | {
-                tag: "Fighter";
-            } | {
-                tag: "Religious";
-            };
-            type Constraint = Constraints.Profession | {
-                tag: "ProfessionSubgroup";
-                subgroup: ProfessionSubgroup;
-            };
-            /**
-             * This defines how the list of constraints should be offset against the
-             * list of all mundane professions: Either only the professions are kept
-             * that intersect with the constraints (include) or only the professions
-             * are kept that are different from the constraints (exclude).
-             */
-            type Operation = {
-                tag: "Intersection";
-            } | {
-                tag: "Difference";
-            };
-            /**
-             * A list of professions. The filter specifies how the list is applied to
-             * all mundane professions.
-             */
-            type T = {
-                /**
-                 * The list of professions.
-                 * @minItems 1
-                 */
-                constraints: Constraint[];
-                /**
-                 * This defines how the list of constraints should be offset against the
-                 * list of all mundane professions: Either only the professions are kept
-                 * that intersect with the constraints (include) or only the professions
-                 * are kept that are different from the constraints (exclude).
-                 */
-                operation: Operation;
-            };
-        }
-        namespace Magic {
-            /**
-             * Some professions are more common than others. There may be cultures
-             * where some professions are not represented at all.
-             */
-            type WeightedProfessions = {
-                /**
-                 * The list of more common variants.
-                 * @minItems 1
-                 */
-                professions: Profession[];
-                /**
-                 * The "weight" difference compared to other professions. Some
-                 * professions are simply more common (Mostly), but sometimes only
-                 * specific professions are used (Only).
-                 */
-                weight: Weight;
-            };
-            type Constraint = {
-                tag: "Tradition";
-                /**
-                 * The magical tradition's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-                /**
-                 * Some professions are more common than others. There may be cultures
-                 * where some professions are not represented at all.
-                 */
-                weighted_professions?: WeightedProfessions;
-                /**
-                 * Some traditions may be found in a culture, but are not that common.
-                 */
-                rarity?: Rarity;
-            } | {
-                tag: "MagicDilettante";
-            } | Constraints.Profession;
-            type T = {
-                /**
-                 * The list of professions.
-                 * @minItems 1
-                 */
-                constraints: Constraint[];
-            };
-        }
-        namespace Blessed {
-            type Constraint = {
-                tag: "Tradition";
-                /**
-                 * The blessed tradition's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-                /**
-                 * Some traditions may be found in a culture, but are not that common.
-                 */
-                rarity?: Rarity;
-            };
-            type T = {
-                /**
-                 * The list of professions.
-                 * @minItems 1
-                 */
-                constraints: Constraint[];
-            };
-        }
-        /**
-         * Lists of professions by group.
-         * @minProperties 2
-         */
-        type T = {
-            tag: "Grouped";
-            /**
-             * A list of professions. The filter specifies how the list is applied to
-             * all mundane professions.
-             */
-            mundane?: Mundane.T;
-            magic?: Magic.T;
-            blessed?: Blessed.T;
-        };
-    }
-    /**
-     * A list of professions that are typical for the culture, as well as
-     * professions that are rarely practiced or encountered in the culture. The
-     * list is either defined by group (as multiple lists) or plain (as a single
-     * list).
-     */
-    type Config = Plain.T | Grouped.T;
-}
-declare type CommonnessRatedSkill = {
+export declare type MundaneProfessionSubgroupConstraint = {
+    tag: "Profane";
+} | {
+    tag: "Fighter";
+} | {
+    tag: "Religious";
+};
+export declare type TraditionConstraint = {
     /**
-     * The skill's identifier.
+     * The magical tradition's identifier.
      * @integer
      * @minimum 1
      */
     id: number;
+    /**
+     * Some professions are more common than others. There may be cultures
+     * where some professions are not represented at all.
+     */
+    weighted_professions?: Weighted<ProfessionReference>;
+    /**
+     * Some traditions may be found in a culture, but are not that common.
+     */
+    rarity?: Rarity;
+};
+export declare type MundaneCommonProfessionConstraint = {
+    tag: "Profession";
+    profession: ProfessionConstraint;
+} | {
+    tag: "ProfessionSubgroup";
+    profession_subgroup: ProfessionConstraint;
+};
+export declare type MagicCommonProfessionConstraint = {
+    tag: "Tradition";
+    tradition: TraditionConstraint;
+} | {
+    tag: "MagicDilettante";
+} | {
+    tag: "Profession";
+    profession: ProfessionConstraint;
+};
+export declare type BlessedCommonProfessionConstraint = {
+    tag: "Tradition";
+    tradition: TraditionConstraint;
+};
+export declare type PlainCommonProfessions = CommonProfessionConstraints<ProfessionReference>;
+/**
+ * Lists of professions by group.
+ * @minProperties 2
+ */
+export declare type GroupedCommonProfessions = {
+    mundane?: CommonProfessionConstraints<MundaneCommonProfessionConstraint>;
+    magic?: CommonProfessionConstraints<MagicCommonProfessionConstraint>;
+    blessed?: CommonProfessionConstraints<BlessedCommonProfessionConstraint>;
+};
+/**
+ * A list of professions that are typical for the culture, as well as
+ * professions that are rarely practiced or encountered in the culture. The
+ * list is either defined by group (as multiple lists) or plain (as a single
+ * list).
+ */
+export declare type CommonProfessions = {
+    tag: "Plain";
+    plain: PlainCommonProfessions;
+} | {
+    tag: "Grouped";
+    grouped: GroupedCommonProfessions;
 };
-declare type CulturalPackageItem = {
+export declare type CommonnessRatedSkill = SkillReference;
+export declare type CulturalPackageItem = {
     /**
      * The skill's identifier.
      * @integer
@@ -380,7 +266,7 @@ declare type CulturalPackageItem = {
      */
     points: number;
 };
-declare type Translation = {
+export declare type CultureTranslation = {
     /**
      * The name of the state.
      * @minLength 1
@@ -392,24 +278,20 @@ declare type Translation = {
     area_knowledge: AreaKnowledgeTranslation;
     /**
      * The respective common advantages text from the source book.
-     * @minLength 1
      */
-    common_advantages?: string;
+    common_advantages?: NonEmptyString;
     /**
      * The respective common disadvantages text from the source book.
-     * @minLength 1
      */
-    common_disadvantages?: string;
+    common_disadvantages?: NonEmptyString;
     /**
      * The respective uncommon advantages text from the source book.
-     * @minLength 1
      */
-    uncommon_advantages?: string;
+    uncommon_advantages?: NonEmptyString;
     /**
      * The respective uncommon disadvantages text from the source book.
-     * @minLength 1
      */
-    uncommon_disadvantages?: string;
+    uncommon_disadvantages?: NonEmptyString;
     /**
      * Structured description of common names.
      */
@@ -437,15 +319,17 @@ declare type AreaKnowledgeTranslation = {
      */
     examples?: AreaKnowledgeExample[];
 };
-/**
- * @minLength 1
- */
-declare type AreaKnowledgeExample = string;
+export declare type AreaKnowledgeExample = {
+    /**
+     * @minLength 1
+     */
+    area: string;
+};
 /**
  * Structured description of common names.
  * @minProperties 1
  */
-declare type CommonNames = {
+export declare type CommonNames = {
     /**
      * First names can be gender-neutral, but they can also be for a specific
      * binary sex. They are sorted into groups.
@@ -460,16 +344,14 @@ declare type CommonNames = {
     last_name_groups?: NameGroup[];
     /**
      * Special naming rules.
-     * @minLength 1
      */
-    naming_rules?: string;
+    naming_rules?: NonEmptyString;
 };
-declare type NameGroup = {
+export declare type NameGroup = {
     /**
      * The group label.
-     * @minLength 1
      */
-    label: string;
+    label: NonEmptyString;
     /**
      * The binary sex if the group is only for a certain binary sex.
      */
@@ -480,16 +362,12 @@ declare type NameGroup = {
      */
     names: Name[];
 };
-declare type Name = {
-    /**
-     * @minLength 1
-     */
-    name: string;
+export declare type Name = {
+    name: NonEmptyString;
     /**
      * Additional information about the name, appended in parenthesis.
-     * @minLength 1
      */
-    note?: string;
+    note?: NonEmptyString;
 };
 export declare const validateSchema: import("../validation/schema.js").TypeValidator<Culture>;
 export {};

package/lib/types/DerivedCharacteristic.d.ts

@@ -2,6 +2,7 @@
  * @main DerivedCharacteristic
  */
 import { PublicationRefs } from "./source/_PublicationRef.js";
+import { LocaleMap } from "./_LocaleMap.js";
 import { DerivedCharacteristicPrerequisites } from "./_Prerequisite.js";
 /**
  * @title Derived Characteristic
@@ -17,16 +18,10 @@ export declare type DerivedCharacteristic = {
     src: PublicationRefs;
     /**
      * All translations for the entry, identified by IETF language tag (BCP47).
-     * @minProperties 1
      */
-    translations: {
-        /**
-         * @patternProperties ^[a-z]{2}-[A-Z]{2}$
-         */
-        [localeId: string]: Translation;
-    };
+    translations: LocaleMap<DerivedCharacteristicTranslation>;
 };
-declare type Translation = {
+export declare type DerivedCharacteristicTranslation = {
     /**
      * The characteristic's name.
      * @minLength 1
@@ -45,7 +40,7 @@ declare type Translation = {
 /**
  * Possible calculation strings for the final value.
  */
-declare type Calculation = {
+export declare type Calculation = {
     /**
      * The default calculation string.
      * @minLength 1
@@ -63,4 +58,3 @@ declare type Calculation = {
     no_primary?: string;
 };
 export declare const validateSchema: import("../validation/schema.js").TypeValidator<DerivedCharacteristic>;
-export {};

package/lib/types/Disadvantage.d.ts

@@ -4,6 +4,7 @@
 import { Errata } from "./source/_Erratum.js";
 import { PublicationRefs } from "./source/_PublicationRef.js";
 import * as Activatable from "./_Activatable.js";
+import { LocaleMap } from "./_LocaleMap.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
 /**
  * @title Disadvantage
@@ -16,36 +17,31 @@ export declare type Disadvantage = {
     prerequisites?: AdvantageDisadvantagePrerequisites;
     ap_value: Activatable.AdventurePointsValue;
     /**
-     * Does this disadvantage not count towards the maximum of AP to be granted by
+     * Does this disadvantage count towards the maximum of AP to be spent on
      * disadvantages?
      */
-    has_no_maximum_spent_influence?: true;
+    has_maximum_spent_influence: boolean;
     /**
-     * Does this disadvantage exclusively applies to arcane spellworks but not
-     * to magical actions and applications?
+     * Does this disadvantage exclusively applies to arcane spellworks and not
+     * to magical actions and magical applications?
      */
-    is_exclusive_to_arcane_spellworks?: true;
+    is_exclusive_to_arcane_spellworks: boolean;
     src: PublicationRefs;
     /**
      * All translations for the entry, identified by IETF language tag (BCP47).
-     * @minProperties 1
      */
-    translations: {
-        /**
-         * @patternProperties ^[a-z]{2}-[A-Z]{2}$
-         */
-        [localeId: string]: {
-            name: Activatable.Name;
-            name_in_library?: Activatable.NameInLibrary;
-            rules: Activatable.Rules;
-            /**
-             * The range.
-             * @markdown
-             * @minLength 1
-             */
-            range?: string;
-            errata?: Errata;
-        };
-    };
+    translations: LocaleMap<DisadvantageTranslation>;
+};
+export declare type DisadvantageTranslation = {
+    name: Activatable.Name;
+    name_in_library?: Activatable.NameInLibrary;
+    rules: Activatable.Rules;
+    /**
+     * The range.
+     * @markdown
+     * @minLength 1
+     */
+    range?: string;
+    errata?: Errata;
 };
 export declare const validateSchema: import("../validation/schema.js").TypeValidator<Disadvantage>;