@optolith/database-schema 0.77.0 → 0.77.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.77.1](https://github.com/Optolith/database-schema/compare/v0.77.0...v0.77.1) (2026-10-03)
+
+### Features
+
+* generic item and equipment category entities ([c154d95](https://github.com/Optolith/database-schema/commit/c154d955d161b02d8d43d13dad8a6b881a333e92))
+* mark entities sortable by index value ([5c8dd28](https://github.com/Optolith/database-schema/commit/5c8dd28937e9176b431cb8e693e816e06fcfb8d5))
+
 ## [0.77.0](https://github.com/Optolith/database-schema/compare/v0.76.0...v0.77.0) (2026-10-01)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -65,6 +65,7 @@ export type EntityMap = {
   Elixir: Elixir
   ElvenMagicalSong: ElvenMagicalSong
   Enhancement: Enhancement
+  EquipmentCategory: EquipmentCategory
   EquipmentOfBlessedOnes: EquipmentOfBlessedOnes
   EquipmentPackage: EquipmentPackage
   ExperienceLevel: ExperienceLevel
@@ -91,6 +92,7 @@ export type EntityMap = {
   IlluminationRefillOrSupply: IlluminationRefillOrSupply
   Influence: Influence
   InstrumentEnchantment: InstrumentEnchantment
+  Item: Item
   JesterTrick: JesterTrick
   Jewelry: Jewelry
   KarmaSpecialAbility: KarmaSpecialAbility
@@ -317,6 +319,7 @@ export type EnumMap = {
   EncumbranceInfluence: EncumbranceInfluence
   EnhancementAdventurePoints: EnhancementAdventurePoints
   EnhancementPrerequisiteGroup: EnhancementPrerequisiteGroup
+  EquipmentCategoryType: EquipmentCategoryType
   EquipmentIdentifier: EquipmentIdentifier
   ExpressionBasedParameterExpressionValue: ExpressionBasedParameterExpressionValue
   ExpressionBasedPoisonTimeExpressionValue: ExpressionBasedPoisonTimeExpressionValue
@@ -452,6 +455,7 @@ export type EnumMap = {
   SlowSkillCastingTimeUnit: SlowSkillCastingTimeUnit
   SpecialAbilityGroup: SpecialAbilityGroup
   SpecialAbilityIdentifier: SpecialAbilityIdentifier
+  SpecialEquipmentCategoryEntity: SpecialEquipmentCategoryEntity
   SpecificAffectedTargetCategoryIdentifier: SpecificAffectedTargetCategoryIdentifier
   SpecificFromSkillSelectOptionCategoryCategoryOperation: SpecificFromSkillSelectOptionCategoryCategoryOperation
   SpellFilter: SpellFilter
@@ -470,6 +474,7 @@ export type EnumMap = {
   TradeSecretSelectOptionCategory: TradeSecretSelectOptionCategory
   TribePrerequisiteGroup: TribePrerequisiteGroup
   ValueMapStyle: ValueMapStyle
+  ValueRule: ValueRule
   VariantOptionAction: VariantOptionAction<unknown>
   VariantSpecialAbilityAction: VariantSpecialAbilityAction
   Volume: Volume
@@ -503,6 +508,7 @@ export type TypeAliasMap = {
   AllApplicableCloseCombatTechniques: AllApplicableCloseCombatTechniques
   AllApplicableCombatTechniques: AllApplicableCombatTechniques
   AllApplicableRangedCombatTechniques: AllApplicableRangedCombatTechniques
+  AllowedCombatValues: AllowedCombatValues
   AlternativeName: AlternativeName
   AnimalFeed: AnimalFeed
   AnimalPowers: AnimalPowers
@@ -596,6 +602,7 @@ export type TypeAliasMap = {
   CustomDurationUnit: CustomDurationUnit
   CustomMagicalRuneSuboption: CustomMagicalRuneSuboption
   DaggerRitualArcaneEnergyCost: DaggerRitualArcaneEnergyCost
+  DefaultEquipmentCategoryTypeRules: DefaultEquipmentCategoryTypeRules
   DefaultPrimaryAttributeDamageThreshold: DefaultPrimaryAttributeDamageThreshold
   DefaultRangedDamage: DefaultRangedDamage
   DefiniteBookCostVariant: DefiniteBookCostVariant
@@ -24228,6 +24235,126 @@ export interface ElixirEffectForEachQualityLevel {
   qualityLevels: [string, string, string, string, string, string]
 }
 
+export interface EquipmentCategory {
+  /**
+   * The position of the category in the list. This has to be a unique value.
+   */
+  position: number
+
+  /**
+   * The type of the equipment category.
+   */
+  type: EquipmentCategoryType
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: EquipmentCategoryTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type EquipmentCategory_ID = string
+
+export interface EquipmentCategoryTranslation {
+  /**
+   * The equipment category’s name.
+   */
+  name: string
+}
+
+export type EquipmentCategoryType =
+  | {
+    kind: "Default"
+    Default: DefaultEquipmentCategoryTypeRules
+  }
+  | {
+    kind: "Special"
+    Special: SpecialEquipmentCategoryEntity
+  }
+
+export interface DefaultEquipmentCategoryTypeRules {
+  /**
+   * The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.
+   */
+  combatValues: AllowedCombatValues
+
+  /**
+   * Presence of restrictions to certain groups for items in this category.
+   */
+  restrictedTo: ValueRule
+
+  /**
+   * Presence of structure points to certain groups for items in this category.
+   */
+  structurePoints: ValueRule
+
+  /**
+   * Presence of weight to certain groups for items in this category.
+   */
+  weight: ValueRule
+
+  /**
+   * Presence of complexity to certain groups for items in this category.
+   */
+  complexity: ValueRule
+}
+
+/**
+ * The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.
+ */
+export interface AllowedCombatValues {
+  /**
+   * Is the item allowed to be used as a weapon?
+   */
+  isWeaponAllowed: boolean
+
+  /**
+   * Is the item allowed to be used as an armor?
+   */
+  isArmorAllowed: boolean
+}
+
+/**
+ * Defines if an instance MUST/CAN/MUST NOT define a value for this parameter. If multiple rules apply to the same parameter, the order of precedence is Required > Optional > Prohibited.
+ */
+export type ValueRule =
+  | {
+    kind: "Required"
+  }
+  | {
+    kind: "Optional"
+  }
+  | {
+    kind: "Prohibited"
+  }
+
+export type SpecialEquipmentCategoryEntity =
+  | {
+    kind: "AnimalCare"
+  }
+  | {
+    kind: "Book"
+  }
+  | {
+    kind: "Elixir"
+  }
+  | {
+    kind: "GemOrPreciousStone"
+  }
+  | {
+    kind: "Newspaper"
+  }
+  | {
+    kind: "Poison"
+  }
+  | {
+    kind: "WorkingSupernaturalCreature"
+  }
+
 export interface EquipmentOfBlessedOnes {
   /**
    * The cost in silverthalers.
@@ -26132,6 +26259,122 @@ export interface HomunculusTypeTranslation {
   name: string
 }
 
+export interface Item {
+  /**
+   * The categories this item belongs to.
+   */
+  categories: EquipmentCategory_ID[]
+
+  /**
+   * The cost in silverthalers.
+   */
+  cost: Cost
+
+  /**
+   * The weight in kg.
+   */
+  weight: Weight
+
+  /**
+   * The complexity of crafting the item.
+   */
+  complexity?: Complexity
+
+  /**
+   * The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.
+   */
+  structurePoints: StructurePoints
+
+  /**
+   * A list of stat blocks for each close combat technique this weapon can be used with.
+   */
+  meleeUses?: {
+    [closeCombatTechniqueId: string]: MeleeWeaponUse2
+  }
+
+  /**
+   * A list of stat blocks for each ranged combat technique this weapon can be used with.
+   */
+  rangedUses?: {
+    [rangedCombatTechniqueId: string]: RangedWeaponUse2
+  }
+
+  /**
+   * Stats for this item being used as an armor.
+   */
+  armorUse?: SecondaryArmor
+
+  /**
+   * Define if during character creation this weapon can only be bought by a specific subset of characters.
+   */
+  restrictedTo?: RestrictedTo
+
+  /**
+   * The weapon is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecifics
+
+  /**
+   * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
+   */
+  src: PublicationRefs
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: ItemTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type Item_ID = string
+
+export type MeleeWeaponUse2 = MeleeWeapon
+
+export type RangedWeaponUse2 = RangedWeapon
+
+export interface ItemTranslation {
+  /**
+   * The item’s name.
+   */
+  name: string
+
+  /**
+   * An auxiliary name or label of the item, if available.
+   */
+  secondaryName?: string
+
+  /**
+   * Note text.
+   */
+  note?: string
+
+  /**
+   * Special rules text.
+   */
+  rules?: string
+
+  /**
+   * The weapon advantage text.
+   */
+  advantage?: string
+
+  /**
+   * The weapon disadvantage text.
+   */
+  disadvantage?: string
+
+  /**
+   * The weapon is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecificsTranslation
+
+  errata?: Errata
+}
+
 /**
  * Meta Conditions are rule elements that work like conditions in the sense that they have four levels with different effects, but which are not explicitly listed as conditions.
  */

package/lib/main.js

@@ -63,6 +63,7 @@ export const schema = new Schema([
     Types.Element,
     Types.Elixir,
     Types.ElvenMagicalSong,
+    Types.EquipmentCategory,
     Types.EquipmentOfBlessedOnes,
     Types.EquipmentPackage,
     Types.ExperienceLevel,
@@ -87,6 +88,7 @@ export const schema = new Schema([
     Types.IlluminationLightSource,
     Types.IlluminationRefillOrSupply,
     Types.InstrumentEnchantment,
+    Types.Item,
     Types.JesterTrick,
     Types.Jewelry,
     Types.KarmaSpecialAbility,

package/lib/types/Attribute.js

@@ -30,9 +30,7 @@ export const Attribute = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
-    sortOrder: {
-        keyPath: "position",
-    },
+    sortOrder: { keyPath: "position", isIndex: true },
     uniqueConstraints: [
         {
             keyPath: "position",

package/lib/types/DerivedCharacteristic.js

@@ -48,9 +48,7 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
-    sortOrder: {
-        keyPath: "position",
-    },
+    sortOrder: { keyPath: "position", isIndex: true },
     uniqueConstraints: [
         {
             keyPath: "position",

package/lib/types/SkillGroup.js

@@ -30,9 +30,7 @@ export const SkillGroup = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
-    sortOrder: {
-        keyPath: "position",
-    },
+    sortOrder: { keyPath: "position", isIndex: true },
     uniqueConstraints: [
         {
             keyPath: "position",

package/lib/types/SocialStatus.js

@@ -16,6 +16,7 @@ export const SocialStatus = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
+    sortOrder: { keyPath: "position", isIndex: true },
     uniqueConstraints: [
         { keyPath: "position" },
         {

package/lib/types/Talisman.js

@@ -81,7 +81,7 @@ export const Talisman = DB.Entity(import.meta.url, {
             instanceContent: instanceContent.combatUse,
             getDisplayNameAndId,
             getInstanceById,
-        }, { secondary: true })
+        })
         : [],
 });
 const TalismanMeleeWeapon = DB.TypeAlias(import.meta.url, {

package/lib/types/_Identifier.d.ts

@@ -61,6 +61,7 @@ export declare const ElementIdentifier: () => R;
 export declare const ElixirIdentifier: () => R;
 export declare const ElvenMagicalSongIdentifier: () => R;
 export declare const EnhancementIdentifier: () => R;
+export declare const EquipmentCategoryIdentifier: () => R;
 export declare const EquipmentOfBlessedOnesIdentifier: () => R;
 export declare const ExperienceLevelIdentifier: () => R;
 export declare const EyeColorIdentifier: () => R;
@@ -85,6 +86,7 @@ export declare const IlluminationLightSourceIdentifier: () => R;
 export declare const IlluminationRefillOrSupplyIdentifier: () => R;
 export declare const InfluenceIdentifier: () => R;
 export declare const InstrumentEnchantmentIdentifier: () => R;
+export declare const ItemIdentifier: () => R;
 export declare const JesterTrickIdentifier: () => R;
 export declare const JewelryIdentifier: () => R;
 export declare const KarmaSpecialAbilityIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -30,12 +30,14 @@ import { Clothes } from "./equipment/item/Clothes.js";
 import { ClothingPackage } from "./equipment/item/ClothingPackage.js";
 import { Container } from "./equipment/item/Container.js";
 import { Elixir } from "./equipment/item/Elixir.js";
+import { EquipmentCategory } from "./equipment/item/EquipmentCategory.js";
 import { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js";
 import { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js";
 import { HerbalAid } from "./equipment/item/HerbalAid.js";
 import { HerbalPreservation } from "./equipment/item/HerbalPreservation.js";
 import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
+import { Item } from "./equipment/item/Item.js";
 import { Jewelry } from "./equipment/item/Jewelry.js";
 import { Laboratory } from "./equipment/item/Laboratory.js";
 import { Liebesspielzeug } from "./equipment/item/Liebesspielzeug.js";
@@ -225,6 +227,7 @@ export const ElementIdentifier = () => R(Element);
 export const ElixirIdentifier = () => R(Elixir);
 export const ElvenMagicalSongIdentifier = () => R(ElvenMagicalSong);
 export const EnhancementIdentifier = () => R(Enhancement);
+export const EquipmentCategoryIdentifier = () => R(EquipmentCategory);
 export const EquipmentOfBlessedOnesIdentifier = () => R(EquipmentOfBlessedOnes);
 export const ExperienceLevelIdentifier = () => R(ExperienceLevel);
 export const EyeColorIdentifier = () => R(EyeColor);
@@ -249,6 +252,7 @@ export const IlluminationLightSourceIdentifier = () => R(IlluminationLightSource
 export const IlluminationRefillOrSupplyIdentifier = () => R(IlluminationRefillOrSupply);
 export const InfluenceIdentifier = () => R(Influence);
 export const InstrumentEnchantmentIdentifier = () => R(InstrumentEnchantment);
+export const ItemIdentifier = () => R(Item);
 export const JesterTrickIdentifier = () => R(JesterTrick);
 export const JewelryIdentifier = () => R(Jewelry);
 export const KarmaSpecialAbilityIdentifier = () => R(KarmaSpecialAbility);

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

@@ -41,7 +41,7 @@ export const BandageOrRemedy = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -46,7 +46,7 @@ export const CeremonialItem = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -41,7 +41,7 @@ export const Clothes = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -41,7 +41,7 @@ export const Container = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -0,0 +1,121 @@
+import type { NonEmptyArray } from "@elyukai/utils/array/nonEmpty";
+import * as DB from "tsondb/schema/dsl";
+import type { Case } from "tsondb/schema/gen";
+import type { DefaultEquipmentCategoryTypeRules, EquipmentCategory as EquipmentCategoryType, ValueRule } from "../../../../gen/types.js";
+declare const ValueRule: DB.Enum<"ValueRule", {
+    Required: DB.EnumCase<null>;
+    Optional: DB.EnumCase<null>;
+    Prohibited: DB.EnumCase<null>;
+}, []>;
+declare const EquipmentCategoryType: DB.Enum<"EquipmentCategoryType", {
+    Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+        combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+            isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+            isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+        }>, []>>, true>;
+        restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>>;
+    Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
+        AnimalCare: DB.EnumCase<null>;
+        Book: DB.EnumCase<null>;
+        Elixir: DB.EnumCase<null>;
+        GemOrPreciousStone: DB.EnumCase<null>;
+        Newspaper: DB.EnumCase<null>;
+        Poison: DB.EnumCase<null>;
+        WorkingSupernaturalCreature: DB.EnumCase<null>;
+    }, []>>>;
+}, []>;
+declare const DefaultEquipmentCategoryTypeRules: DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+    combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+        isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+        isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+    }>, []>>, true>;
+    restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const EquipmentCategory: DB.Entity<"EquipmentCategory", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EquipmentCategoryType", {
+        Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+            combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+                isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+                isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>, true>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+        Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
+            AnimalCare: DB.EnumCase<null>;
+            Book: DB.EnumCase<null>;
+            Elixir: DB.EnumCase<null>;
+            GemOrPreciousStone: DB.EnumCase<null>;
+            Newspaper: DB.EnumCase<null>;
+            Poison: DB.EnumCase<null>;
+            WorkingSupernaturalCreature: DB.EnumCase<null>;
+        }, []>>>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"EquipmentCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;
+export declare const isEquipmentCategoryOfDefaultType: (category: EquipmentCategoryType) => category is Omit<EquipmentCategoryType, "type"> & {
+    type: Case<"Default", DefaultEquipmentCategoryTypeRules>;
+};
+export declare const mergeValueRules: (categories: NonEmptyArray<ValueRule>) => ValueRule["kind"];
+export declare const mergeAllValueRules: (categories: NonEmptyArray<DefaultEquipmentCategoryTypeRules>) => DefaultEquipmentCategoryTypeRules;
+export {};