ttrpg-engine-dnd 0.1.0-alpha.0

package/dist/schemas/events/charges.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+export declare const RECHARGE_CADENCES: readonly ["dawn", "dusk", "shortRest", "longRest", "manual"];
+export declare const RechargeCadenceSchema: z.ZodEnum<["dawn", "dusk", "shortRest", "longRest", "manual"]>;
+export type RechargeCadence = z.infer<typeof RechargeCadenceSchema>;
+export declare const ItemChargeConsumedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ItemChargeConsumed">;
+    itemInstanceId: z.ZodString;
+    amount: z.ZodNumber;
+    byCharacterId: z.ZodOptional<z.ZodString>;
+    forEffect: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ItemChargeConsumed";
+    amount: number;
+    id: string;
+    itemInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    byCharacterId?: string | undefined;
+    forEffect?: string | undefined;
+}, {
+    at: string;
+    type: "ItemChargeConsumed";
+    amount: number;
+    id: string;
+    itemInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    byCharacterId?: string | undefined;
+    forEffect?: string | undefined;
+}>;
+export type ItemChargeConsumedEvent = z.infer<typeof ItemChargeConsumedEventSchema>;
+export declare const ItemRechargedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ItemRecharged">;
+    itemInstanceId: z.ZodString;
+    amount: z.ZodNumber;
+    cadence: z.ZodEnum<["dawn", "dusk", "shortRest", "longRest", "manual"]>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ItemRecharged";
+    amount: number;
+    id: string;
+    cadence: "shortRest" | "longRest" | "dawn" | "dusk" | "manual";
+    itemInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ItemRecharged";
+    amount: number;
+    id: string;
+    cadence: "shortRest" | "longRest" | "dawn" | "dusk" | "manual";
+    itemInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ItemRechargedEvent = z.infer<typeof ItemRechargedEventSchema>;
+export declare const SentientItemConflictEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"SentientItemConflict">;
+    itemInstanceId: z.ZodString;
+    wielderId: z.ZodString;
+    winner: z.ZodEnum<["item", "wielder"]>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "SentientItemConflict";
+    id: string;
+    itemInstanceId: string;
+    wielderId: string;
+    winner: "item" | "wielder";
+    description?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "SentientItemConflict";
+    id: string;
+    itemInstanceId: string;
+    wielderId: string;
+    winner: "item" | "wielder";
+    description?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type SentientItemConflictEvent = z.infer<typeof SentientItemConflictEventSchema>;
+//# sourceMappingURL=charges.d.ts.map

package/dist/schemas/events/charges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charges.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/charges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB,8DAA+D,CAAC;AAC9F,eAAO,MAAM,qBAAqB,gEAA4B,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/schemas/events/checks.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const CheckAdvantageSchema: z.ZodEnum<["none", "advantage", "disadvantage"]>;
+export type CheckAdvantage = z.infer<typeof CheckAdvantageSchema>;
+export declare const SaveRolledEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"SaveRolled">;
+    targetId: z.ZodString;
+    ability: z.ZodEnum<["STR", "DEX", "CON", "INT", "WIS", "CHA"]>;
+    dc: z.ZodNumber;
+    d20: z.ZodArray<z.ZodNumber, "many">;
+    used: z.ZodEnum<["none", "advantage", "disadvantage"]>;
+    bonus: z.ZodNumber;
+    total: z.ZodNumber;
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "SaveRolled";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+    id: string;
+    dc: number;
+    targetId: string;
+    success: boolean;
+    d20: number[];
+    total: number;
+    used: "none" | "advantage" | "disadvantage";
+    bonus: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "SaveRolled";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+    id: string;
+    dc: number;
+    targetId: string;
+    success: boolean;
+    d20: number[];
+    total: number;
+    used: "none" | "advantage" | "disadvantage";
+    bonus: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type SaveRolledEvent = z.infer<typeof SaveRolledEventSchema>;
+export declare const AbilityCheckRolledEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"AbilityCheckRolled">;
+    characterId: z.ZodString;
+    ability: z.ZodEnum<["STR", "DEX", "CON", "INT", "WIS", "CHA"]>;
+    skill: z.ZodOptional<z.ZodEnum<["acrobatics", "animal-handling", "arcana", "athletics", "deception", "history", "insight", "intimidation", "investigation", "medicine", "nature", "perception", "performance", "persuasion", "religion", "sleight-of-hand", "stealth", "survival"]>>;
+    dc: z.ZodOptional<z.ZodNumber>;
+    d20: z.ZodArray<z.ZodNumber, "many">;
+    used: z.ZodEnum<["none", "advantage", "disadvantage"]>;
+    bonus: z.ZodNumber;
+    total: z.ZodNumber;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "AbilityCheckRolled";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+    id: string;
+    characterId: string;
+    d20: number[];
+    total: number;
+    used: "none" | "advantage" | "disadvantage";
+    bonus: number;
+    skill?: "acrobatics" | "animal-handling" | "arcana" | "athletics" | "deception" | "history" | "insight" | "intimidation" | "investigation" | "medicine" | "nature" | "perception" | "performance" | "persuasion" | "religion" | "sleight-of-hand" | "stealth" | "survival" | undefined;
+    dc?: number | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    success?: boolean | undefined;
+}, {
+    at: string;
+    type: "AbilityCheckRolled";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+    id: string;
+    characterId: string;
+    d20: number[];
+    total: number;
+    used: "none" | "advantage" | "disadvantage";
+    bonus: number;
+    skill?: "acrobatics" | "animal-handling" | "arcana" | "athletics" | "deception" | "history" | "insight" | "intimidation" | "investigation" | "medicine" | "nature" | "perception" | "performance" | "persuasion" | "religion" | "sleight-of-hand" | "stealth" | "survival" | undefined;
+    dc?: number | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    success?: boolean | undefined;
+}>;
+export type AbilityCheckRolledEvent = z.infer<typeof AbilityCheckRolledEventSchema>;
+//# sourceMappingURL=checks.d.ts.map

package/dist/schemas/events/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/checks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oBAAoB,kDAAgD,CAAC;AAClF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/schemas/events/combat.d.ts

@@ -0,0 +1,308 @@
+import { z } from 'zod';
+export declare const DAMAGE_MITIGATION_KINDS: readonly ["resisted", "immune", "vulnerable"];
+export declare const DamageMitigationKindSchema: z.ZodEnum<["resisted", "immune", "vulnerable"]>;
+export type DamageMitigationKind = z.infer<typeof DamageMitigationKindSchema>;
+export declare const DamageComponentSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    type: z.ZodEnum<["acid", "bludgeoning", "cold", "fire", "force", "lightning", "necrotic", "piercing", "poison", "psychic", "radiant", "slashing", "thunder"]>;
+    rawAmount: z.ZodOptional<z.ZodNumber>;
+    mitigation: z.ZodOptional<z.ZodEnum<["resisted", "immune", "vulnerable"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+    amount: number;
+    rawAmount?: number | undefined;
+    mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+}, {
+    type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+    amount: number;
+    rawAmount?: number | undefined;
+    mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+}>;
+export type DamageComponent = z.infer<typeof DamageComponentSchema>;
+export declare const DamageAppliedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"DamageApplied">;
+    targetId: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        type: z.ZodEnum<["acid", "bludgeoning", "cold", "fire", "force", "lightning", "necrotic", "piercing", "poison", "psychic", "radiant", "slashing", "thunder"]>;
+        rawAmount: z.ZodOptional<z.ZodNumber>;
+        mitigation: z.ZodOptional<z.ZodEnum<["resisted", "immune", "vulnerable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+        amount: number;
+        rawAmount?: number | undefined;
+        mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+    }, {
+        type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+        amount: number;
+        rawAmount?: number | undefined;
+        mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "DamageApplied";
+    id: string;
+    components: {
+        type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+        amount: number;
+        rawAmount?: number | undefined;
+        mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+    }[];
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "DamageApplied";
+    id: string;
+    components: {
+        type: "acid" | "bludgeoning" | "cold" | "fire" | "force" | "lightning" | "necrotic" | "piercing" | "poison" | "psychic" | "radiant" | "slashing" | "thunder";
+        amount: number;
+        rawAmount?: number | undefined;
+        mitigation?: "resisted" | "immune" | "vulnerable" | undefined;
+    }[];
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type DamageAppliedEvent = z.infer<typeof DamageAppliedEventSchema>;
+export declare const HealedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"Healed">;
+    targetId: z.ZodString;
+    amount: z.ZodNumber;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "Healed";
+    amount: number;
+    id: string;
+    targetId: string;
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "Healed";
+    amount: number;
+    id: string;
+    targetId: string;
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type HealedEvent = z.infer<typeof HealedEventSchema>;
+export declare const TempHPGrantedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"TempHPGranted">;
+    targetId: z.ZodString;
+    amount: z.ZodNumber;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "TempHPGranted";
+    amount: number;
+    id: string;
+    targetId: string;
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "TempHPGranted";
+    amount: number;
+    id: string;
+    targetId: string;
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type TempHPGrantedEvent = z.infer<typeof TempHPGrantedEventSchema>;
+export declare const ConditionAppliedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ConditionApplied">;
+    targetId: z.ZodString;
+    conditionId: z.ZodString;
+    level: z.ZodOptional<z.ZodNumber>;
+    expiresOnRound: z.ZodOptional<z.ZodNumber>;
+    appliedConditionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ConditionApplied";
+    conditionId: string;
+    id: string;
+    targetId: string;
+    level?: number | undefined;
+    expiresOnRound?: number | undefined;
+    appliedConditionId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ConditionApplied";
+    conditionId: string;
+    id: string;
+    targetId: string;
+    level?: number | undefined;
+    expiresOnRound?: number | undefined;
+    appliedConditionId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ConditionAppliedEvent = z.infer<typeof ConditionAppliedEventSchema>;
+export declare const ConditionRemovedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ConditionRemoved">;
+    targetId: z.ZodString;
+    conditionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ConditionRemoved";
+    conditionId: string;
+    id: string;
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ConditionRemoved";
+    conditionId: string;
+    id: string;
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ConditionRemovedEvent = z.infer<typeof ConditionRemovedEventSchema>;
+export declare const ExhaustionChangedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ExhaustionChanged">;
+    targetId: z.ZodString;
+    fromLevel: z.ZodNumber;
+    toLevel: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ExhaustionChanged";
+    id: string;
+    targetId: string;
+    fromLevel: number;
+    toLevel: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ExhaustionChanged";
+    id: string;
+    targetId: string;
+    fromLevel: number;
+    toLevel: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ExhaustionChangedEvent = z.infer<typeof ExhaustionChangedEventSchema>;
+export declare const DeathSaveRolledEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"DeathSaveRolled">;
+    targetId: z.ZodString;
+    d20: z.ZodNumber;
+    success: z.ZodBoolean;
+    critical: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "DeathSaveRolled";
+    id: string;
+    targetId: string;
+    success: boolean;
+    d20: number;
+    critical: boolean;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "DeathSaveRolled";
+    id: string;
+    targetId: string;
+    success: boolean;
+    d20: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    critical?: boolean | undefined;
+}>;
+export type DeathSaveRolledEvent = z.infer<typeof DeathSaveRolledEventSchema>;
+export declare const StabilizedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"Stabilized">;
+    targetId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "Stabilized";
+    id: string;
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "Stabilized";
+    id: string;
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type StabilizedEvent = z.infer<typeof StabilizedEventSchema>;
+//# sourceMappingURL=combat.d.ts.map

package/dist/schemas/events/combat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combat.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/combat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB,+CAAgD,CAAC;AACrF,eAAO,MAAM,0BAA0B,iDAAkC,CAAC;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/events/concentration.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export declare const ConcentrationStartedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ConcentrationStarted">;
+    effectInstanceId: z.ZodString;
+    casterId: z.ZodString;
+    spellId: z.ZodString;
+    targetIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    conditionsApplied: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        targetId: z.ZodString;
+        conditionId: z.ZodString;
+        appliedConditionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }, {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }>, "many">>;
+    durationRounds: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ConcentrationStarted";
+    id: string;
+    spellId: string;
+    casterId: string;
+    targetIds: string[];
+    conditionsApplied: {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }[];
+    effectInstanceId: string;
+    durationRounds?: number | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ConcentrationStarted";
+    id: string;
+    spellId: string;
+    casterId: string;
+    effectInstanceId: string;
+    durationRounds?: number | undefined;
+    targetIds?: string[] | undefined;
+    conditionsApplied?: {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }[] | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ConcentrationStartedEvent = z.infer<typeof ConcentrationStartedEventSchema>;
+export declare const ConcentrationBrokenReasonSchema: z.ZodEnum<["failedSave", "newConcentrationSpell", "voluntary", "incapacitated", "dead", "durationEnded"]>;
+export type ConcentrationBrokenReason = z.infer<typeof ConcentrationBrokenReasonSchema>;
+export declare const ConcentrationBrokenEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    causedByEventId: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"ConcentrationBroken">;
+    effectInstanceId: z.ZodString;
+    casterId: z.ZodString;
+    reason: z.ZodEnum<["failedSave", "newConcentrationSpell", "voluntary", "incapacitated", "dead", "durationEnded"]>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ConcentrationBroken";
+    id: string;
+    casterId: string;
+    reason: "failedSave" | "newConcentrationSpell" | "voluntary" | "incapacitated" | "dead" | "durationEnded";
+    effectInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ConcentrationBroken";
+    id: string;
+    casterId: string;
+    reason: "failedSave" | "newConcentrationSpell" | "voluntary" | "incapacitated" | "dead" | "durationEnded";
+    effectInstanceId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type ConcentrationBrokenEvent = z.infer<typeof ConcentrationBrokenEventSchema>;
+//# sourceMappingURL=concentration.d.ts.map

package/dist/schemas/events/concentration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concentration.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/concentration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,eAAO,MAAM,+BAA+B,2GAO1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}