@datasworn-community/build-tools 0.2.0

package/schema-source/schema/Defs.ts

@@ -0,0 +1,126 @@
+import { type TSchema, Type } from '@sinclair/typebox'
+import { pickBy } from 'lodash-es'
+import { DefsKey } from '../scripts/const.js'
+import Log from '../scripts/utils/Log.js'
+import * as Assets from './Assets.js'
+import * as Atlas from './Atlas.js'
+import Id from './common/Id.js'
+import * as Metadata from './common/Metadata.js'
+import * as Player from './common/Player.js'
+import * as Progress from './common/Progress.js'
+import { DiceRange } from './common/Range.js'
+import * as RollableValues from './common/RollableValues.js'
+import * as Rolls from './common/Rolls.js'
+import * as Text from './common/Text.js'
+import * as DelveSites from './DelveSites.js'
+import * as Entities from './Entities.js'
+import * as Moves from './Moves.js'
+import * as Npcs from './Npcs.js'
+import * as Oracles from './Oracles.js'
+import * as Rarities from './Rarities.js'
+import * as Rules from './Rules.js'
+import { Expansion, Ruleset, RulesPackage } from './RulesPackages.js'
+import { isValidTagSchema } from './rules/TagSchema.js'
+import * as Truths from './Truths.js'
+import { UnionEnum } from './Utils.js'
+
+function validateSchemaDefinitions(defs: Record<string, TSchema>) {
+	const usedRefs = new Set<string>()
+	const availableRefs = new Set<string>()
+
+	// lazy way to iterate over all values
+	void JSON.stringify(defs, (k, v) => {
+		if (k === '$ref' && typeof v === 'string') usedRefs.add(v)
+		if (k === '$id' && typeof v === 'string') availableRefs.add(v)
+		return v
+	})
+
+	const invalidPointers = new Set<string>()
+	const unusedDefinitions = new Set<string>()
+
+	const allPointers = new Set<string>([...usedRefs, ...availableRefs])
+
+	for (const pointer of allPointers) {
+		if (pointer.startsWith('http')) continue
+		if (!usedRefs.has(pointer)) unusedDefinitions.add(pointer)
+		if (!availableRefs.has(pointer)) invalidPointers.add(pointer)
+	}
+
+	// console.log('unusedDefinitions', unusedDefinitions)
+	if (invalidPointers.size > 0)
+		throw new Error(
+			`Missing referenced definitions: ${Array.from(invalidPointers).join(', ')}`
+		)
+}
+
+const defsBase = pickBy(
+	{
+		RulesPackage,
+		Ruleset,
+		Expansion,
+		...Id,
+		...Metadata,
+		...Text,
+		...Rules,
+		...Progress,
+		...RollableValues,
+		...Npcs,
+		...Rolls,
+		DiceRange,
+		...Entities,
+		...Oracles,
+		...Moves,
+		...Assets,
+		...Truths,
+		...Atlas,
+		...Player,
+		...Rarities,
+		...DelveSites
+	} as Record<string, TSchema>,
+	(schema, key) => {
+		if (typeof schema !== 'object') return false
+
+		if (typeof schema.$id !== 'string') {
+			Log.warn(`Schema in #/${DefsKey}, but doesn't have an ID?`)
+			Log.warn(JSON.stringify(schema))
+			return false
+		}
+
+		if (key !== schema.$id)
+			Log.warn(`Schema has $id ${schema.$id}, but its key is ${key}`)
+
+		return true
+	}
+)
+
+validateSchemaDefinitions(defsBase)
+
+export type Defs = Record<string, TSchema>
+const entries: [string, TSchema][] = Object.values<TSchema>(defsBase)
+	.filter((entry): entry is TSchema & { $id: string } => entry.$id != null)
+	.map((entry) => [entry.$id, entry])
+
+const Defs: Defs = Object.fromEntries(
+	entries.sort(([a], [b]) => a.localeCompare(b))
+)
+
+// special: update the '$ref' subschema of SafeValue schema so that it's an enum of all  Datasworn schemata references that are valid for use in tags.
+
+const _schemaToUpdate = Rules.TagSchema
+
+const enumValues: string[] = []
+
+for (const k in Defs) {
+	const def = Defs[k]
+	if (def?.title?.includes('Tag') || def?.$id?.includes('Tag')) continue
+	if (isValidTagSchema(def)) enumValues.push(`#/${DefsKey}/${k}`)
+}
+
+const union = Rules.TagSchema.allOf[0]
+const _dataswornRef = union.anyOf[0]
+union.anyOf[0] = Type.Object(
+	{ $ref: UnionEnum(enumValues) },
+	{ additionalProperties: true }
+)
+
+export default Defs

package/schema-source/schema/DelveSites.ts

@@ -0,0 +1,3 @@
+export * from './delve/DelveSite.js'
+export * from './delve/DelveSiteDomain.js'
+export * from './delve/DelveSiteTheme.js'

package/schema-source/schema/Entities.ts

@@ -0,0 +1 @@
+export * from './entities/index.js'

package/schema-source/schema/Generic.ts

@@ -0,0 +1,18 @@
+export * from './generic/CollectableNode.js'
+export * from './generic/CollectionNode.js'
+export * from './generic/Dictionary.js'
+export * from './generic/Enhance.js'
+export * from './generic/IdNode.js'
+export * from './generic/Mixin.js'
+export * from './generic/NonCollectableNode.js'
+export * from './generic/SourcedNode.js'
+
+// Utility type for runtime collection handling
+import type { SourcedNode } from './generic/SourcedNode.js'
+export type Collection<TContent = any> = {
+	contents: Record<string, TContent>
+	collections?: Record<string, Collection<any>>
+} & SourcedNode
+
+// Utility type for collectable items
+export type Collectable<TContent = unknown> = TContent & SourcedNode

package/schema-source/schema/Moves.ts

@@ -0,0 +1 @@
+export * from './moves/index.js'

package/schema-source/schema/Npcs.ts

@@ -0,0 +1,80 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Progress from './common/Progress.js'
+import * as Text from './common/Text.js'
+import * as Generic from './Generic.js'
+import { EmbedOnlyNode } from './generic/EmbedOnlyNode.js'
+import { Namespace } from './Symbols.js'
+import { FlatIntersect } from './utils/FlatIntersect.js'
+
+const ns = 'Npcs'
+
+export const NpcNature = Type.Ref(Text.Label, {
+	description:
+		"A localized category label describing the nature of this NPC.\n\nIn Ironsworn classic, this is probably the singular form of the parent collection's name.\n\nFor Starforged, see the table on p. 258 for examples.",
+	examples: [
+		// classic natures
+		'Ironlander',
+		'Firstborn',
+		'Animal',
+		'Beast',
+		'Horror',
+		'Anomaly',
+		// Starforged natures
+		'Creature',
+		// 'Horror',
+		'Human',
+		'Machine',
+		'Monster',
+		'Vehicle'
+	],
+	$id: 'NpcNature',
+	[Namespace]: ns
+})
+export type NpcNature = Static<typeof NpcNature>
+
+const NpcMixin = FlatIntersect([
+	Generic.Cyclopedia,
+	Type.Object({
+		rank: Type.Ref(Progress.ChallengeRank, {
+			description: 'The suggested challenge rank for this NPC.'
+		}),
+		nature: Type.Ref(NpcNature),
+		drives: Type.Array(Type.Ref(Text.MarkdownString)),
+		tactics: Type.Array(Type.Ref(Text.MarkdownString))
+	})
+])
+
+export const NpcVariant = EmbedOnlyNode(
+	Type.Pick(NpcMixin, ['name', 'rank', 'nature', 'summary', 'description']),
+	'variant',
+	'npc'
+)
+
+export type NpcVariant = Static<typeof NpcVariant>
+
+export const Npc = Generic.CollectableNode(
+	FlatIntersect([
+		NpcMixin,
+		Type.Object({
+			variants: Generic.Dictionary(Type.Ref(NpcVariant))
+		})
+	]),
+	'npc',
+	{
+		[Namespace]: ns,
+		description:
+			'A non-player character entry, similar to those in Chapter 5 of the Ironsworn Rulebook, or Chapter 4 of Starforged.'
+	}
+)
+
+export type Npc = Static<typeof Npc>
+
+export const NpcCollection = Generic.CollectionNode(
+	Type.Object({}),
+	'npc_collection',
+	{
+		[Namespace]: ns
+	}
+)
+export type NpcCollection = Static<typeof NpcCollection>
+export type TNpcCollection = typeof NpcCollection

package/schema-source/schema/Oracles.ts

@@ -0,0 +1,20 @@
+// constituent types
+
+// derived type
+export * from './oracles/EmbeddedOracleRollable.js'
+export {
+	OracleCollection,
+	OracleTableSharedRolls,
+	OracleTableSharedText,
+	OracleTableSharedText2,
+	OracleTableSharedText3,
+	OracleTablesCollection
+} from './oracles/OracleCollection.js'
+// primary type
+export * from './oracles/OracleRollable.js'
+export {
+	OracleRollableRow,
+	OracleRollableRowText,
+	OracleRollableRowText2,
+	OracleRollableRowText3
+} from './oracles/TableRow.js'

package/schema-source/schema/Rarities.ts

@@ -0,0 +1,36 @@
+import { type Static, Type } from '@sinclair/typebox'
+import Id from './common/Id.js'
+import { MarkdownString } from './common/Text.js'
+import { NonCollectableNode } from './Generic.js'
+import { setSourceDataSchema } from './Utils.js'
+
+export const Rarity = setSourceDataSchema(
+	NonCollectableNode(
+		Type.Object({
+			asset: Type.Ref(Id.AssetId, {
+				description: 'The asset augmented by this rarity.'
+			}),
+			description: Type.Ref(MarkdownString, {
+				description: 'A description of this rarity.'
+			}),
+			xp_cost: Type.Integer({
+				minimum: 3,
+				maximum: 5,
+				default: 3,
+				description: `From Ironsworn: Delve, p. 174:
+
+      Some assets will bring a rarity into play more often than others, so the experience point cost for a rarity will vary by the linked asset. These costs are shown in the tables on page 175.
+
+      If you are playing solo, and aren’t concerned with the relative balance of rarity abilities, you can ignore these variable costs. If so, spend 3 experience points to purchase a rarity.`
+			})
+		}),
+		'rarity',
+		{
+			$id: 'Rarity',
+			description: 'A rarity, as described in Ironsworn: Delve.'
+		}
+	),
+	(schema) => ({ ...schema, additionalProperties: true })
+)
+export type Rarity = Static<typeof Rarity>
+export type TRarity = typeof Rarity

package/schema-source/schema/Root.ts

@@ -0,0 +1,94 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as CONST from '../scripts/const.js'
+import { RulesetId } from './common/Id.js'
+import Defs from './Defs.js'
+import {
+	Asset,
+	DelveSite,
+	DelveSiteDomain,
+	DelveSiteTheme,
+	Move,
+	Npc,
+	OracleRollable,
+	Rarity
+} from './index.js'
+import { RulesPackage, Version } from './RulesPackages.js'
+import { RootObject, SourceRootObject } from './root/Root.js'
+import * as Utils from './Utils.js'
+
+const RootObjectMixin = Type.Object(
+	{
+		datasworn_version: Version,
+		ruleset: Type.Ref(RulesetId)
+	},
+	{ additionalProperties: true }
+)
+
+const StandaloneNode = Type.Intersect([
+	Utils.DiscriminatedUnion(
+		{
+			asset: Asset,
+			npc: Npc,
+			move: Move,
+			oracle_rollable: OracleRollable,
+			// delve types
+			delve_site: DelveSite,
+			delve_site_theme: DelveSiteTheme,
+			delve_site_domain: DelveSiteDomain,
+			rarity: Rarity
+		},
+		'type'
+	),
+	RootObjectMixin
+])
+
+// this isn't friendly to JTD, but currently the source schema isn't processed for JTD anyways
+const SourceRoot = Type.Union([Type.Ref(RulesPackage), StandaloneNode], {
+	$id: 'SourceRoot',
+	description:
+		'The root object for a Datasworn source file, whose schema is discriminated by the `type` property. Unlike the JSON schema for distribution, this may be a standalone object (Asset, Npc, Move, OracleRollable, DelveSite, DelveSiteTheme, DelveSiteDomain, or Rarity), but it still must specify its `ruleset` and `datasworn_version`.'
+})
+
+export const DataswornSchema = RootObject(Type.Ref(RulesPackage), {
+	$schema: CONST.$schema,
+	$id: CONST.SCHEMA_ID,
+	title: `Datasworn v${CONST.VERSION}`,
+	description:
+		'Describes game rules compatible with the Ironsworn tabletop role-playing game by Shawn Tomkin.',
+	[CONST.DefsKey]: Defs
+})
+
+export const DataswornSourceSchema = SourceRootObject(Type.Ref(SourceRoot), {
+	$schema: CONST.$schema,
+	$id: CONST.SOURCE_SCHEMA_ID,
+	title: `DataswornSource v${CONST.VERSION}`,
+	description:
+		'Source data schema for Datasworn, which describes game rules compatible with the Ironsworn tabletop roleplaying game by Shawn Tomkin.\n\nThe source data omits IDs, and makes properties that provide a default value optional; these values are inserted during validation/processing to produce the JSON for distribution.',
+	// additionalProperties: true,
+	[CONST.DefsKey]: { SourceRoot, ...Defs }
+})
+
+export type DataswornSchema = Static<typeof DataswornSchema>
+export type DataswornSourceSchema = Static<typeof DataswornSourceSchema>
+
+// for (const schema of [
+// 	Defs.Asset,
+// 	...Object.values(Defs.Move[Mapping]),
+// 	...Object.values(Defs.OracleRollable[Mapping]),
+// 	Defs.AtlasEntry,
+// 	Defs.Npc,
+// 	Defs.DelveSiteTheme,
+// 	Defs.DelveSiteDomain,
+// 	Defs.DelveSite
+// ]) {
+// 	const base = {
+// 		type: schema.properties.type.const
+// 	}
+// 	for (const k in schema.properties) {
+// 		if (k.endsWith('_type')) base[k] = schema.properties[k].const
+// 	}
+// 	console.log(
+// 		schema.$id,
+// 		Value.Default(schema, Object.values(DataswornSchema[CONST.DefsKey]), base)
+// 	)
+// }

package/schema-source/schema/Rules.ts

@@ -0,0 +1,61 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Generic from './Generic.js'
+import { ConditionMeterRule } from './rules/ConditionMeterRule.js'
+import { ImpactCategory } from './rules/ImpactRule.js'
+import { SpecialTrackRule } from './rules/SpecialTrackRule.js'
+import { StatRule } from './rules/StatRule.js'
+import { TagRule } from './rules/TagRule.js'
+
+export * from './rules/ConditionMeterRule.js'
+export * from './rules/ImpactRule.js'
+export * from './rules/SpecialTrackRule.js'
+export * from './rules/StatRule.js'
+export * from './rules/TagRule.js'
+
+export const Rules = Type.Object(
+	{
+		stats: Generic.Dictionary(Type.Ref(StatRule, { default: undefined }), {
+			description:
+				'Describes the standard stats used by player characters in this ruleset.'
+		}),
+		condition_meters: Generic.Dictionary(
+			Type.Ref(ConditionMeterRule, { default: undefined }),
+			{
+				description:
+					'Describes the standard condition meters used by player characters in this ruleset.'
+			}
+		),
+		impacts: Generic.Dictionary(
+			Type.Ref(ImpactCategory, { default: undefined }),
+			{
+				description:
+					'Describes the standard impacts/debilities used by player characters in this ruleset.'
+			}
+		),
+		special_tracks: Generic.Dictionary(
+			Type.Ref(SpecialTrackRule, { default: undefined }),
+			{
+				description:
+					'Describes the special tracks used by player characters in this ruleset, like Bonds (classic Ironsworn), Failure (Delve), or Legacies (Starforged).'
+			}
+		),
+		tags: Generic.Dictionary(Type.Ref(TagRule), {
+			releaseStage: 'experimental'
+		})
+	},
+	{
+		$id: 'Rules',
+		description:
+			'Describes rules for player characters in this ruleset, such as stats and condition meters.',
+		releaseStage: 'experimental'
+	}
+)
+export type Rules = Static<typeof Rules>
+export type TRules = typeof Rules
+
+export const RulesExpansion = Type.Partial(Rules, {
+	$id: 'RulesExpansion'
+})
+
+export type RulesExpansion = Static<typeof RulesExpansion>
+export type TRulesExpansion = typeof RulesExpansion

package/schema-source/schema/RulesPackages.ts

@@ -0,0 +1,135 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { mapValues } from 'lodash-es'
+import { rootSchemaName, VERSION } from '../scripts/const.js'
+import { SourceInfo } from './common/Metadata.js'
+import * as Text from './common/Text.js'
+import * as Generic from './Generic.js'
+import * as Rules from './Rules.js'
+import * as Utils from './Utils.js'
+import { Assign } from './utils/FlatIntersect.js'
+
+export const Version = Type.Literal(VERSION, {
+	description: 'The version of the Datasworn format used by this data.',
+	pattern:
+		/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
+			.source
+})
+
+const RulesPackageBase = Type.Object({
+	_id: Type.Ref('RulesPackageId'),
+	type: Type.String(),
+	// name: Utils.SourceOptional(Type.Ref(Text.Label)),
+	datasworn_version: Version,
+	description: Type.Optional(Type.Ref(Text.MarkdownString)),
+	...mapValues(Type.Required(Type.Omit(SourceInfo, ['page'])).properties, (v) =>
+		Utils.setSourceOptional(v)
+	),
+	oracles: Utils.setSourceOptional(
+		Generic.Dictionary(Type.Ref('OracleTablesCollection'), {
+			description:
+				'A dictionary object containing oracle collections, which may contain oracle tables and/or oracle collections.'
+		})
+	),
+	moves: Utils.setSourceOptional(
+		Generic.Dictionary(Type.Ref('MoveCategory'), {
+			description:
+				'A dictionary object containing move categories, which contain moves.'
+		})
+	),
+	assets: Utils.setSourceOptional(
+		Generic.Dictionary(Type.Ref('AssetCollection'), {
+			description:
+				'A dictionary object containing asset collections, which contain assets.'
+		})
+	),
+	atlas: Type.Optional(
+		Generic.Dictionary(Type.Ref('AtlasCollection'), {
+			description:
+				'A dictionary object containing atlas collections, which contain atlas entries.'
+		})
+	),
+	npcs: Type.Optional(
+		Generic.Dictionary(Type.Ref('NpcCollection'), {
+			description:
+				'A dictionary object containing NPC collections, which contain NPCs.'
+		})
+	),
+	truths: Type.Optional(
+		Generic.Dictionary(Type.Ref('Truth'), {
+			description: 'A dictionary object of truth categories.'
+		})
+	),
+	rarities: Type.Optional(
+		Generic.Dictionary(Type.Ref('Rarity'), {
+			description:
+				'A dictionary object containing rarities, like those presented in Ironsworn: Delve.'
+		})
+	),
+	delve_sites: Type.Optional(
+		Generic.Dictionary(Type.Ref('DelveSite'), {
+			description:
+				'A dictionary object of delve sites, like the premade delve sites presented in Ironsworn: Delve'
+		})
+	),
+	site_themes: Type.Optional(
+		Generic.Dictionary(Type.Ref('DelveSiteTheme'), {
+			description: 'A dictionary object containing delve site themes.'
+		})
+	),
+	site_domains: Type.Optional(
+		Generic.Dictionary(Type.Ref('DelveSiteDomain'), {
+			description: 'A dictionary object containing delve site domains.'
+		})
+	)
+})
+
+export const Ruleset = Assign(
+	RulesPackageBase,
+	Type.Object({
+		_id: Type.Ref('RulesetId'),
+		type: Type.Literal('ruleset'),
+		rules: Utils.setSourceOptional(Type.Ref(Rules.Rules))
+	}),
+	{
+		$id: 'Ruleset',
+		additionalProperties: true,
+		description:
+			'A standalone Datasworn package that describes its own ruleset.'
+	}
+)
+
+export type Ruleset = Static<typeof Ruleset>
+
+export const Expansion = Assign(
+	Type.Omit(RulesPackageBase, ['rules']),
+	Type.Object({
+		_id: Type.Ref('ExpansionId'),
+		type: Type.Literal('expansion'),
+		ruleset: Type.Ref('RulesetId'),
+		rules: Type.Optional(Type.Ref(Rules.RulesExpansion))
+	}),
+	{
+		additionalProperties: true,
+
+		description:
+			'A Datasworn package that relies on an external package to provide its ruleset.',
+		$id: 'Expansion'
+	}
+)
+export type Expansion = Static<typeof Expansion>
+
+export const RulesPackage = Utils.DiscriminatedUnion(
+	{
+		ruleset: Ruleset,
+		expansion: Expansion
+	},
+	'type',
+	{
+		description:
+			'Describes game rules compatible with the Ironsworn tabletop role-playing game by Shawn Tomkin.',
+		title: rootSchemaName,
+		$id: rootSchemaName
+	}
+)
+
+export type RulesPackage = Static<typeof RulesPackage>

package/schema-source/schema/Symbols.ts

@@ -0,0 +1,30 @@
+/** Override type for typescript code generation. */
+export const Typescript = Symbol('Typescript')
+
+/** Hints type relationships between schemata. */
+export const Extends = Symbol('Extends')
+
+/** Use with SchemaOptions to hint/override JTD generation. */
+export const JsonTypeDef = Symbol('JsonTypeDef')
+/** Hints discriminator key for DiscriminatedUnion schemata  */
+export const Discriminator = Symbol('Discriminator')
+/** Stores references to the member schema in a discriminated union */
+export const Members = Symbol('Members')
+/** Stores references to the member schema in a discriminated union */
+export const Mapping = Symbol('Mapping')
+
+/** A less complex alternate version of the schema for use with code generation tools. */
+export const Simplify = Symbol('Simplify')
+
+/**
+ * Details type inheritance for use in code generation.
+ */
+export const Inherits = Symbol('Inherits')
+
+/**
+ * Sets the namespace/module name for use in code generation.
+ */
+export const Namespace = Symbol('Namespace')
+
+/** Marks a property as being inherited from another schema. */
+export const InheritedFrom = Symbol('InheritedFrom')

package/schema-source/schema/Truths.ts

@@ -0,0 +1,53 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { DiceRange } from './common/Range.js'
+import { DiceExpression } from './common/Rolls.js'
+import * as Text from './common/Text.js'
+import { EntityPrompt } from './entities/EntityPrompt.js'
+import * as Generic from './Generic.js'
+import { EmbeddedOracleRollable } from './oracles/EmbeddedOracleRollable.js'
+
+export type TruthOption = Static<typeof TruthOption>
+
+export const TruthOption = Generic.IdNode(
+	Type.Object({
+		roll: Type.Ref(DiceRange),
+		summary: Type.Optional(Type.Ref(Text.MarkdownString)),
+		description: Type.Ref(Text.MarkdownString),
+		quest_starter: Type.Ref(Text.MarkdownString),
+		oracles: Type.Optional(
+			Generic.Dictionary(
+				Type.Ref(EmbeddedOracleRollable, {
+					title: 'TruthOptionOracleRollable'
+				}),
+				{
+					title: 'TruthOptionOracles'
+				}
+			)
+		)
+	}),
+	Type.Ref('TruthOptionId'),
+	{ $id: 'TruthOption' }
+)
+
+export const Truth = Generic.NonCollectableNode(
+	Type.Object({
+		dice: Type.Ref(DiceExpression, { default: '1d100' }),
+		options: Type.Array(Type.Ref(TruthOption), { rollable: true }),
+		your_character: Type.Optional(Type.Ref(Text.MarkdownString)),
+		factions: Type.Optional(
+			Type.Array(Type.Ref(EntityPrompt), {
+				description:
+					'Prompts for factions related to this truth, like those presented in standard isles. This is presented as a single paragraph in the original text; Datasworn uses an array (one faction prompt per string) to represent them in order to make them more suitable for programmatic use.\n\nThis property is a placeholder and may see signficant changes in v0.2.0.',
+				releaseStage: 'experimental'
+			})
+		)
+	}),
+	'truth',
+	{
+		$id: 'Truth',
+		description: 'A setting truth category.'
+	}
+)
+
+export type Truth = Static<typeof Truth>
+export type TTruth = typeof Truth