optolith-database-schema 0.1.4 → 0.1.5

package/lib/types/_Prerequisite.d.ts

@@ -1,413 +1,109 @@
 /**
  * @title Prerequisites
  */
-import { Identifier } from "./_Identifier";
-import { BinarySex } from "./_Sex";
-export declare namespace Prerequisite {
+import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, SpellworkPrerequisiteGroup } from "./prerequisites/PrerequisiteGroups";
+/**
+ * @title Prerequisite Collection Types
+ */
+declare namespace PrerequisiteCollection {
     /**
-     * @title Single Prerequisites
+     * 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.
      */
-    export namespace Single {
-        namespace DisplayOption {
-            /**
-             * @title Display Option
-             */
-            type T = {
-                tag: "Hide";
-            } | {
-                tag: "ReplaceWith";
-                /**
-                 * All translations for the entry, identified by IETF language tag (BCP47).
-                 * @minProperties 1
-                 */
-                translations: {
-                    /**
-                     * @patternProperties ^[a-z]{2}-[A-Z]{2}$
-                     */
-                    [localeId: string]: string;
-                };
-            };
-        }
-        namespace Sex {
-            /**
-             * Requires a specific sex.
-             * @title Sex Prerequisite
-             */
-            type T = {
-                tag: "Sex";
-                id: BinarySex;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace Race {
-            /**
-             * Requires a specific culture or one of a specific set of cultures.
-             * @title Race Prerequisite
-             */
-            export type T = {
-                tag: "Culture";
-                id: Identifier;
-                active: boolean;
-                display_option?: DisplayOption.T;
-            };
-            type Identifier = SingleIdentifier | MultipleIdentifiers;
-            /**
-             * @minimum 1
-             */
-            type SingleIdentifier = number;
-            /**
-             * @minItems 2
-             */
-            type MultipleIdentifiers = SingleIdentifier[];
-            export {};
-        }
-        namespace Culture {
-            /**
-             * Requires a specific race or one of a specific set of races. You can also
-             * provide an object to say whether the hero must meet one of the races or
-             * if the entry does not allow one of the races.
-             * @title Culture Prerequisite
-             */
-            export type T = {
-                tag: "Culture";
-                id: Identifier;
-                display_option?: DisplayOption.T;
-            };
-            type Identifier = SingleIdentifier | MultipleIdentifiers;
-            /**
-             * @minimum 1
-             */
-            type SingleIdentifier = number;
-            /**
-             * @minItems 2
-             */
-            type MultipleIdentifiers = SingleIdentifier[];
-            export {};
-        }
-        namespace Rule {
-            /**
-             * @title Rule Prerequisite
-             */
-            export type T = {
-                tag: "Rule";
-                id: Identifier;
-                display_option?: DisplayOption.T;
-            };
-            type Identifier = {
-                tag: "FocusRule";
-                /**
-                 * @integer
-                 * @minimum 1
-                 */
-                value: number;
-            } | {
-                tag: "OptionalRule";
-                /**
-                 * @integer
-                 * @minimum 1
-                 */
-                value: number;
-            };
-            export {};
-        }
-        namespace Publication {
-            /**
-             * @title Publication Prerequisite
-             */
-            type T = {
-                tag: "Publication";
-                /**
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace PrimaryAttribute {
-            /**
-             * @title Primary Attribute Prerequisite
-             */
-            type T = {
-                tag: "PrimaryAttribute";
-                /**
-                 * Is the required primary attribute for spellcasters or blessed ones?
-                 */
-                category: Category;
-                /**
-                 * Required value of the attribute
-                 * @integer
-                 * @minimum 9
-                 */
-                value: number;
-                display_option?: DisplayOption.T;
-            };
-            type Category = {
-                tag: "Blessed";
-            } | {
-                tag: "Magical";
-            };
-        }
-        namespace Pact {
+    export type Group<T> = {
+        tag: "Group";
+        /**
+         * @minItems 2
+         */
+        list: T[];
+        /**
+         * All translations for the entry, identified by IETF language tag (BCP47).
+         * @minProperties 1
+         */
+        translations: {
             /**
-             * Requires a specific pact.
-             * @title Pact Prerequisite
+             * @patternProperties ^[a-z]{2}-[A-Z]{2}$
+             * @minLength 1
              */
-            type T = {
-                tag: "Pact";
-                /**
-                 * The required pact category's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                category_id: number;
-                /**
-                 * The required domains' identifiers.
-                 */
-                domain_id?: DomainId[];
-                /**
-                 * The required pact level.
-                 * @integer
-                 * @minimum 1
-                 */
-                level?: number;
-                display_option?: DisplayOption.T;
-            };
+            [localeId: string]: string;
+        };
+    };
+    type SingleAndGrouped<T> = T | Group<T>;
+    export type Plain<T> = {
+        tag: "Plain";
+        /**
+         * @minItems 1
+         */
+        list: SingleAndGrouped<T>[];
+    };
+    export type ByLevel<T> = Plain<T> | {
+        tag: "ByLevel";
+        /**
+         * @minItems 1
+         */
+        list: {
             /**
-             * A domain's identifier.
              * @integer
              * @minimum 1
              */
-            type DomainId = number;
-        }
-        namespace SocialStatus {
-            /**
-             * Requires a minimum social status.
-             * @title Social Status Prerequisite
-             */
-            type T = {
-                tag: "SocialStatus";
-                /**
-                 * The minimum social status' identifier.
-                 * @integer
-                 * @minimum 2
-                 * @maximum 5
-                 */
-                id: number;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace Influence {
-            /**
-             * @title Influence Prerequisite
-             */
-            type T = {
-                tag: "Influence";
-                /**
-                 * The influence's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-                /**
-                 * If the referenced influence must or must not be chosen.
-                 */
-                active: boolean;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace Activatable {
-            /**
-             * Requires a specific advantage, disadvantage, special ability.
-             * @title Activatable Prerequisite
-             */
-            type T = {
-                tag: "Activatable";
-                /**
-                 * The activatable entry's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: Identifier.Group.Activatable;
-                /**
-                 * If the required entry should be required to be active or inactive.
-                 */
-                active: boolean;
-                /**
-                 * The required minimum level of the entry.
-                 * @integer
-                 * @minimum 1
-                 */
-                level?: number;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace Rated {
-            /**
-             * @title Rated Prerequisite
-             */
-            type T = {
-                tag: "Rated";
-                /**
-                 * The rated entry's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: Identifier.Group.Rated;
-                /**
-                 * The required minimum value.
-                 * @integer
-                 * @minimum 0
-                 */
-                value: number;
-                display_option?: DisplayOption.T;
-            };
-        }
-        namespace Enhancement {
-            /**
-             * Requires a specific enhancement from a skill.
-             * @title Enhancement Prerequisite
-             */
-            type T = {
-                tag: "Enhancement";
-                /**
-                 * The required skill's identifier.
-                 */
-                skill: {
-                    tag: SkillCategoryWithEnhancements;
-                    /**
-                     * The skill's identifier.
-                     * @integer
-                     * @minimum 1
-                     */
-                    id: number;
-                };
-                /**
-                 * The required enhancement's identifier.
-                 */
-                enhancement: {
-                    /**
-                     * The enhancement's identifier.
-                     * @integer
-                     * @minimum 1
-                     */
-                    id: number;
-                };
-                display_option?: DisplayOption.T;
-            };
-            enum SkillCategoryWithEnhancements {
-                Spell = "Spell",
-                Ritual = "Ritual",
-                LiturgicalChant = "LiturgicalChant",
-                Ceremony = "Ceremony"
-            }
-        }
-        namespace EnhancementInternal {
-            /**
-             * Requires a specific enhancement from a skill. This can only be used by an
-             * enhancement to require another enhancement from the same skill.
-             * @title Internal Enhancement Prerequisite
-             */
-            type T = {
-                tag: "EnhancementInternal";
-                /**
-                 * The enhancement's identifier.
-                 * @integer
-                 * @minimum 1
-                 */
-                id: number;
-            };
-        }
-        namespace Ineligible {
-            /**
-             * This is a placeholder for required things that can never happen with the
-             * current set of crunch elements and rules, e. g. if a race is required
-             * that does not yet exist as a crunch element.
-             *
-             * A display option must be set.
-             * @title Ineligible Prerequisite
-             */
-            type T = {
-                tag: "Ineligible";
-                display_option: DisplayOption.T;
-            };
-        }
-    }
-    /**
-     * @title Grouped Prerequisites
-     */
-    namespace Group {
-        type DerivedCharacteristic = Single.Rule.T;
-        type Publication = Single.Publication.T;
-        type ArcaneTradition = Single.Sex.T | Single.Culture.T;
-        type Spellwork = Single.Rule.T | Single.Rated.T;
-        type Liturgy = Single.Rule.T;
-        type Language = Single.Ineligible.T | Single.Race.T | Single.Activatable.T;
-        type GeodeRitual = Single.Influence.T;
-        type Enhancement = Single.EnhancementInternal.T;
-    }
-    /**
-     * @title Prerequisite Collection Types
-     */
-    namespace Collection {
-        type Plain<T> = {
-            tag: "Plain";
-            /**
-             * @minItems 1
-             */
-            value: T[];
-        };
-        type ByLevel<T> = {
-            tag: "Plain";
+            level: number;
             /**
              * @minItems 1
              */
-            value: T[];
-        } | {
-            tag: "ByLevel";
-            /**
-             * @minItems 1
-             */
-            value: {
-                /**
-                 * @integer
-                 * @minimum 1
-                 */
-                level: number;
-                prerequisites: T[];
-            }[];
-        };
-    }
-    /**
-     * @title Grouped Prerequisite Collections
-     */
-    export namespace GroupCollection {
-        type DerivedCharacteristic = Collection.Plain<Group.DerivedCharacteristic>;
-        type Publication = Collection.Plain<Group.Publication>;
-        /**
-         * @title Arcane Tradition Prerequisites
-         */
-        type ArcaneTradition = Collection.Plain<Group.ArcaneTradition>;
-        /**
-         * @title Spellwork Prerequisites
-         */
-        type Spellwork = Collection.Plain<Group.Spellwork>;
-        /**
-         * @title Liturgy Prerequisites
-         */
-        type Liturgy = Collection.Plain<Group.Liturgy>;
-        /**
-         * @title Language Prerequisites
-         */
-        type Language = Collection.ByLevel<Group.Language>;
-        /**
-         * @title Geode Ritual Prerequisites
-         */
-        type GeodeRitual = Collection.Plain<Group.GeodeRitual>;
-        /**
-         * @title Enhancement Prerequisites
-         */
-        type Enhancement = Collection.Plain<Group.Enhancement>;
-    }
+            prerequisites: SingleAndGrouped<T>[];
+        }[];
+    };
     export {};
 }
+export declare type DerivedCharacteristicPrerequisites = PrerequisiteCollection.Plain<DerivedCharacteristicPrerequisiteGroup>;
+export declare type PublicationPrerequisites = PrerequisiteCollection.Plain<PublicationPrerequisiteGroup>;
+/**
+ * @title General Prerequisites
+ */
+export declare type GeneralPrerequisites = PrerequisiteCollection.ByLevel<GeneralPrerequisiteGroup>;
+/**
+ * @title Profession Prerequisites
+ */
+export declare type ProfessionPrerequisites = PrerequisiteCollection.Plain<ProfessionPrerequisiteGroup>;
+/**
+ * @title Advantage/Disadvantage Prerequisites
+ */
+export declare type AdvantageDisadvantagePrerequisites = PrerequisiteCollection.ByLevel<AdvantageDisadvantagePrerequisiteGroup>;
+/**
+ * @title Arcane Tradition Prerequisites
+ */
+export declare type ArcaneTraditionPrerequisites = PrerequisiteCollection.Plain<ArcaneTraditionPrerequisiteGroup>;
+/**
+ * @title Personality Trait Prerequisites
+ */
+export declare type PersonalityTraitPrerequisites = PrerequisiteCollection.Plain<PersonalityTraitPrerequisiteGroup>;
+/**
+ * @title Spellwork Prerequisites
+ */
+export declare type SpellworkPrerequisites = PrerequisiteCollection.Plain<SpellworkPrerequisiteGroup>;
+/**
+ * @title Liturgy Prerequisites
+ */
+export declare type LiturgyPrerequisites = PrerequisiteCollection.Plain<LiturgyPrerequisiteGroup>;
+/**
+ * @title Influence Prerequisites
+ */
+export declare type InfluencePrerequisites = PrerequisiteCollection.Plain<InfluencePrerequisiteGroup>;
+/**
+ * @title Language Prerequisites
+ */
+export declare type LanguagePrerequisites = PrerequisiteCollection.ByLevel<LanguagePrerequisiteGroup>;
+/**
+ * @title Animist Power Prerequisites
+ */
+export declare type AnimistPowerPrerequisites = PrerequisiteCollection.Plain<AnimistPowerPrerequisiteGroup>;
+/**
+ * @title Geode Ritual Prerequisites
+ */
+export declare type GeodeRitualPrerequisites = PrerequisiteCollection.Plain<GeodeRitualPrerequisiteGroup>;
+/**
+ * @title Enhancement Prerequisites
+ */
+export declare type EnhancementPrerequisites = PrerequisiteCollection.Plain<EnhancementPrerequisiteGroup>;
+export {};

package/lib/types/_Prerequisite.js

@@ -1,139 +1,4 @@
 /**
  * @title Prerequisites
  */
-export var Prerequisite;
-(function (Prerequisite) {
-    /**
-     * @title Single Prerequisites
-     */
-    let Single;
-    (function (Single) {
-        //       "IncreasableMultiEntry": {
-        //         "title": "Increasable Prerequisite",
-        //         "description": "Require a specific attribute, skill, combat technique, spell or chant from a set to be on a minimum value. Note that liturgical chants are required to be active automatically, so to require them to be active you can set the value to 0.",
-        //         "type": "object",
-        //         "properties": {
-        //           "tag": { "const": "IncreasableMultiEntry" },
-        //           "id": {
-        //             "type": "object",
-        //             "properties": {
-        //               "tag": { "$ref": "_Id.schema.json#/definitions/Rated" },
-        //               "value": {
-        //                 "type": "array",
-        //                 "items": { "type": "integer", "minimum": 1 },
-        //                 "uniqueItems": true,
-        //                 "minItems": 2
-        //               }
-        //             },
-        //             "required": ["tag", "value"],
-        //             "additionalProperties": false
-        //           },
-        //           "value": {
-        //             "description": "The required minimum value.",
-        //             "type": "integer",
-        //             "minimum": 0
-        //           },
-        //           "display_option": { "$ref": "#/definitions/Single/DisplayOption" }
-        //         },
-        //         "required": ["tag", "id", "value"],
-        //         "additionalProperties": false
-        //       },
-        //       "AnimistPower": {
-        //         "title": "Animist Power Prerequisite",
-        //         "description": "Requires a specific animist power to be on a minimum value.",
-        //         "type": "object",
-        //         "properties": {
-        //           "tag": { "const": "AnimistPower" },
-        //           "id": { "type": "integer", "minimum": 1 },
-        //           "level": {
-        //             "description": "The level to which the minimum value applies.",
-        //             "type": "integer",
-        //             "minimum": 0
-        //           },
-        //           "value": {
-        //             "description": "The required minimum value.",
-        //             "type": "integer",
-        //             "minimum": 0
-        //           }
-        //         },
-        //         "required": ["tag", "id", "value"],
-        //         "additionalProperties": false
-        //       },
-        //       "MinimumSkillRating": {
-        //         "type": "object",
-        //         "properties": {
-        //           "tag": { "const": "MinimumSkillRating" },
-        //           "number": {
-        //             "description": "The minimum number of skills that need to be on the defined minimum skill rating.",
-        //             "type": "integer",
-        //             "minimum": 1
-        //           },
-        //           "value": {
-        //             "description": "The minimum skill rating the defined minimum number of skills need to be on.",
-        //             "type": "integer",
-        //             "minimum": 1
-        //           },
-        //           "targets": {
-        //             "oneOf": [
-        //               {
-        //                 "type": "object",
-        //                 "properties": {
-        //                   "type": {
-        //                     "const": "Skills"
-        //                   },
-        //                   "id": {
-        //                     "type": "array",
-        //                     "items": { "type": "integer", "minimum": 1 },
-        //                     "minItems": 1
-        //                   }
-        //                 },
-        //                 "required": ["type", "id"],
-        //                 "additionalProperties": false
-        //               },
-        //               {
-        //                 "type": "object",
-        //                 "properties": {
-        //                   "type": {
-        //                     "const": "Spellworks"
-        //                   },
-        //                   "property": {
-        //                     "type": "integer",
-        //                     "minimum": 1
-        //                   }
-        //                 },
-        //                 "required": ["type", "property"],
-        //                 "additionalProperties": false
-        //               },
-        //               {
-        //                 "type": "object",
-        //                 "properties": {
-        //                   "type": {
-        //                     "const": "Liturgies"
-        //                   },
-        //                   "aspect": {
-        //                     "type": "integer",
-        //                     "minimum": 1
-        //                   }
-        //                 },
-        //                 "required": ["type", "aspect"],
-        //                 "additionalProperties": false
-        //               }
-        //             ]
-        //           },
-        //           "display_option": { "$ref": "#/definitions/Single/DisplayOption" }
-        //         },
-        //         "required": ["tag", "number", "value", "targets"],
-        //         "additionalProperties": false
-        //       },
-        let Enhancement;
-        (function (Enhancement) {
-            let SkillCategoryWithEnhancements;
-            (function (SkillCategoryWithEnhancements) {
-                SkillCategoryWithEnhancements["Spell"] = "Spell";
-                SkillCategoryWithEnhancements["Ritual"] = "Ritual";
-                SkillCategoryWithEnhancements["LiturgicalChant"] = "LiturgicalChant";
-                SkillCategoryWithEnhancements["Ceremony"] = "Ceremony";
-            })(SkillCategoryWithEnhancements = Enhancement.SkillCategoryWithEnhancements || (Enhancement.SkillCategoryWithEnhancements = {}));
-        })(Enhancement = Single.Enhancement || (Single.Enhancement = {}));
-    })(Single = Prerequisite.Single || (Prerequisite.Single = {}));
-})(Prerequisite || (Prerequisite = {}));
+export {};

package/lib/types/magicalActions/AnimistPower.d.ts

@@ -142,6 +142,11 @@ export declare type AnimistPower = {
                 full: string;
                 abbr: string;
             };
+            /**
+             * A prerequisites text.
+             * @deprecated
+             */
+            prerequisites?: string;
             errata?: Errata;
         };
     };

package/lib/types/magicalActions/GeodeRitual.d.ts

@@ -5,7 +5,7 @@ import { SlowSkillCastingTimeUnit } from "../SkillModificationLevel";
 import { Errata } from "../source/_Erratum";
 import { PublicationRefs } from "../source/_PublicationRef";
 import { Cost, Duration, Effect, TargetCategory } from "../_ActivatableSkill";
-import { Prerequisite } from "../_Prerequisite";
+import { GeodeRitualPrerequisites } from "../_Prerequisite";
 import { SkillCheck } from "../_SkillCheck";
 /**
  * @title Geode Ritual
@@ -35,7 +35,7 @@ export declare type GeodeRitual = {
      * @minimum 1
      */
     property_id: number;
-    prerequisites?: Prerequisite.GroupCollection.GeodeRitual;
+    prerequisites?: GeodeRitualPrerequisites;
     src: PublicationRefs;
     /**
      * All translations for the entry, identified by IETF language tag (BCP47).

package/lib/types/prerequisites/ConditionalPrerequisites.d.ts

@@ -0,0 +1,10 @@
+import { PreconditionGroup } from "./PrerequisiteGroups";
+/**
+ * A list of preconditions for the prerequisite it is defined on, so that it
+ * only takes effect if the prerequisites in this list are matched.
+ *
+ * Usually appears at the `when` property of the parent prerequisite.
+ * @title Preconditions (`when`)
+ * @minItems 1
+ */
+export declare type Preconditions = PreconditionGroup[];