optolith-database-schema 0.2.4 → 0.4.1

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,170 @@ 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;
 };
-declare type Script = {
+/**
+ * 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 enum Weight {
+    Mostly = "Mostly",
+    Only = "Only"
+}
+/**
+ * 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";
-} | {
-    tag: "Adjustable";
+export declare enum CommonProfessionConstraintsOperation {
+    Intersection = "Intersection",
+    Difference = "Difference"
+}
+/**
+ * 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;
 };
-declare type SocialStatus = {
+/**
+ * Some professions may be found in a culture, but are not that common.
+ */
+export declare enum Rarity {
+    Rare = "Rare",
+    VeryRare = "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;
+export declare enum MundaneProfessionSubgroupConstraint {
+    Profane = "Profane",
+    Fighter = "Fighter",
+    Religious = "Religious"
 }
-declare type CommonnessRatedSkill = {
+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";
+    magic_dilettante: {};
+} | {
+    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 +262,7 @@ declare type CulturalPackageItem = {
      */
     points: number;
 };
-declare type Translation = {
+export declare type CultureTranslation = {
     /**
      * The name of the state.
      * @minLength 1
@@ -392,24 +274,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 +315,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 +340,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 +358,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/Culture.js

@@ -2,4 +2,42 @@
  * @main Culture
  */
 import { validateSchemaCreator } from "../validation/schema.js";
+/**
+ * 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 var Weight;
+(function (Weight) {
+    Weight["Mostly"] = "Mostly";
+    Weight["Only"] = "Only";
+})(Weight || (Weight = {}));
+/**
+ * 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).
+ */
+export var CommonProfessionConstraintsOperation;
+(function (CommonProfessionConstraintsOperation) {
+    CommonProfessionConstraintsOperation["Intersection"] = "Intersection";
+    CommonProfessionConstraintsOperation["Difference"] = "Difference";
+})(CommonProfessionConstraintsOperation || (CommonProfessionConstraintsOperation = {}));
+/**
+ * Some professions may be found in a culture, but are not that common.
+ */
+export var Rarity;
+(function (Rarity) {
+    Rarity["Rare"] = "Rare";
+    Rarity["VeryRare"] = "VeryRare";
+})(Rarity || (Rarity = {}));
+/**
+ * Some professions may be found in a culture, but are not that common.
+ */
+export var MundaneProfessionSubgroupConstraint;
+(function (MundaneProfessionSubgroupConstraint) {
+    MundaneProfessionSubgroupConstraint["Profane"] = "Profane";
+    MundaneProfessionSubgroupConstraint["Fighter"] = "Fighter";
+    MundaneProfessionSubgroupConstraint["Religious"] = "Religious";
+})(MundaneProfessionSubgroupConstraint || (MundaneProfessionSubgroupConstraint = {}));
 export const validateSchema = validateSchemaCreator(import.meta.url);

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 {};