ttrpg-engine-dnd 0.1.0-alpha.0

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

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+export declare const POLYMORPH_KINDS: readonly ["polymorph", "wild-shape", "true-polymorph"];
+export declare const PolymorphKindSchema: z.ZodEnum<["polymorph", "wild-shape", "true-polymorph"]>;
+export type PolymorphKind = z.infer<typeof PolymorphKindSchema>;
+export declare const PolymorphFormSchema: z.ZodObject<{
+    name: z.ZodString;
+    hp: z.ZodNumber;
+    ac: z.ZodNumber;
+    abilityScores: z.ZodObject<{
+        STR: z.ZodNumber;
+        DEX: z.ZodNumber;
+        CON: z.ZodNumber;
+        INT: z.ZodNumber;
+        WIS: z.ZodNumber;
+        CHA: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        STR: number;
+        DEX: number;
+        CON: number;
+        INT: number;
+        WIS: number;
+        CHA: number;
+    }, {
+        STR: number;
+        DEX: number;
+        CON: number;
+        INT: number;
+        WIS: number;
+        CHA: number;
+    }>;
+    speedFeet: z.ZodNumber;
+    speciesId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ac: number;
+    name: string;
+    hp: number;
+    abilityScores: {
+        STR: number;
+        DEX: number;
+        CON: number;
+        INT: number;
+        WIS: number;
+        CHA: number;
+    };
+    speedFeet: number;
+    speciesId?: string | undefined;
+}, {
+    ac: number;
+    name: string;
+    hp: number;
+    abilityScores: {
+        STR: number;
+        DEX: number;
+        CON: number;
+        INT: number;
+        WIS: number;
+        CHA: number;
+    };
+    speedFeet: number;
+    speciesId?: string | undefined;
+}>;
+export type PolymorphForm = z.infer<typeof PolymorphFormSchema>;
+export declare const PolymorphAppliedEventSchema: 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<"PolymorphApplied">;
+    targetId: z.ZodString;
+    casterId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<["polymorph", "wild-shape", "true-polymorph"]>;
+    form: z.ZodObject<{
+        name: z.ZodString;
+        hp: z.ZodNumber;
+        ac: z.ZodNumber;
+        abilityScores: z.ZodObject<{
+            STR: z.ZodNumber;
+            DEX: z.ZodNumber;
+            CON: z.ZodNumber;
+            INT: z.ZodNumber;
+            WIS: z.ZodNumber;
+            CHA: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        }, {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        }>;
+        speedFeet: z.ZodNumber;
+        speciesId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        ac: number;
+        name: string;
+        hp: number;
+        abilityScores: {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        };
+        speedFeet: number;
+        speciesId?: string | undefined;
+    }, {
+        ac: number;
+        name: string;
+        hp: number;
+        abilityScores: {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        };
+        speedFeet: number;
+        speciesId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "PolymorphApplied";
+    kind: "polymorph" | "wild-shape" | "true-polymorph";
+    id: string;
+    targetId: string;
+    form: {
+        ac: number;
+        name: string;
+        hp: number;
+        abilityScores: {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        };
+        speedFeet: number;
+        speciesId?: string | undefined;
+    };
+    casterId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "PolymorphApplied";
+    kind: "polymorph" | "wild-shape" | "true-polymorph";
+    id: string;
+    targetId: string;
+    form: {
+        ac: number;
+        name: string;
+        hp: number;
+        abilityScores: {
+            STR: number;
+            DEX: number;
+            CON: number;
+            INT: number;
+            WIS: number;
+            CHA: number;
+        };
+        speedFeet: number;
+        speciesId?: string | undefined;
+    };
+    casterId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type PolymorphAppliedEvent = z.infer<typeof PolymorphAppliedEventSchema>;
+export declare const PolymorphRevertedEventSchema: 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<"PolymorphReverted">;
+    targetId: z.ZodString;
+    reason: z.ZodDefault<z.ZodEnum<["voluntary", "forced-zero-hp", "duration-expired"]>>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "PolymorphReverted";
+    id: string;
+    targetId: string;
+    reason: "voluntary" | "forced-zero-hp" | "duration-expired";
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "PolymorphReverted";
+    id: string;
+    targetId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    reason?: "voluntary" | "forced-zero-hp" | "duration-expired" | undefined;
+}>;
+export type PolymorphRevertedEvent = z.infer<typeof PolymorphRevertedEventSchema>;
+export declare const SimulacrumCreatedEventSchema: 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<"SimulacrumCreated">;
+    simulacrumId: z.ZodString;
+    originalId: z.ZodString;
+    hpMax: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "SimulacrumCreated";
+    hpMax: number;
+    id: string;
+    simulacrumId: string;
+    originalId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "SimulacrumCreated";
+    hpMax: number;
+    id: string;
+    simulacrumId: string;
+    originalId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type SimulacrumCreatedEvent = z.infer<typeof SimulacrumCreatedEventSchema>;
+export declare const WishGrantedEventSchema: 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<"WishGranted">;
+    granterId: z.ZodString;
+    description: z.ZodString;
+    stressApplied: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "WishGranted";
+    id: string;
+    description: string;
+    granterId: string;
+    stressApplied: boolean;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "WishGranted";
+    id: string;
+    description: string;
+    granterId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    stressApplied?: boolean | undefined;
+}>;
+export type WishGrantedEvent = z.infer<typeof WishGrantedEventSchema>;
+//# sourceMappingURL=transformations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe,wDAAyD,CAAC;AACtF,eAAO,MAAM,mBAAmB,0DAA0B,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

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

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+export declare const TravelLegCompletedEventSchema: 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<"TravelLegCompleted">;
+    partyId: z.ZodString;
+    pace: z.ZodEnum<["slow", "normal", "fast"]>;
+    hours: z.ZodNumber;
+    miles: z.ZodNumber;
+    fromLocationId: z.ZodOptional<z.ZodString>;
+    toLocationId: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "TravelLegCompleted";
+    id: string;
+    hours: number;
+    partyId: string;
+    pace: "normal" | "slow" | "fast";
+    miles: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    fromLocationId?: string | undefined;
+    toLocationId?: string | undefined;
+    notes?: string | undefined;
+}, {
+    at: string;
+    type: "TravelLegCompleted";
+    id: string;
+    hours: number;
+    partyId: string;
+    pace: "normal" | "slow" | "fast";
+    miles: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    fromLocationId?: string | undefined;
+    toLocationId?: string | undefined;
+    notes?: string | undefined;
+}>;
+export type TravelLegCompletedEvent = z.infer<typeof TravelLegCompletedEventSchema>;
+export declare const NavigationCheckRolledEventSchema: 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<"NavigationCheckRolled">;
+    partyId: z.ZodString;
+    navigatorId: z.ZodString;
+    d20: z.ZodNumber;
+    bonus: z.ZodNumber;
+    total: z.ZodNumber;
+    dc: z.ZodNumber;
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "NavigationCheckRolled";
+    id: string;
+    dc: number;
+    partyId: string;
+    success: boolean;
+    d20: number;
+    total: number;
+    bonus: number;
+    navigatorId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "NavigationCheckRolled";
+    id: string;
+    dc: number;
+    partyId: string;
+    success: boolean;
+    d20: number;
+    total: number;
+    bonus: number;
+    navigatorId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type NavigationCheckRolledEvent = z.infer<typeof NavigationCheckRolledEventSchema>;
+export declare const ForagedForEventSchema: 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<"ForagedFor">;
+    partyId: z.ZodString;
+    foragerId: z.ZodString;
+    d20: z.ZodNumber;
+    bonus: z.ZodNumber;
+    total: z.ZodNumber;
+    dc: z.ZodNumber;
+    success: z.ZodBoolean;
+    foodPounds: z.ZodDefault<z.ZodNumber>;
+    waterPounds: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "ForagedFor";
+    id: string;
+    dc: number;
+    partyId: string;
+    success: boolean;
+    d20: number;
+    total: number;
+    bonus: number;
+    foragerId: string;
+    foodPounds: number;
+    waterPounds: number;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "ForagedFor";
+    id: string;
+    dc: number;
+    partyId: string;
+    success: boolean;
+    d20: number;
+    total: number;
+    bonus: number;
+    foragerId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    foodPounds?: number | undefined;
+    waterPounds?: number | undefined;
+}>;
+export type ForagedForEvent = z.infer<typeof ForagedForEventSchema>;
+//# sourceMappingURL=travel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"travel.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/travel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const TriggerFiredEventSchema: 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<"TriggerFired">;
+    characterId: z.ZodString;
+    triggerId: z.ZodString;
+    cadence: z.ZodDefault<z.ZodObject<{
+        firedThisTurn: z.ZodOptional<z.ZodBoolean>;
+        firedThisRound: z.ZodOptional<z.ZodBoolean>;
+        firedThisShortRest: z.ZodOptional<z.ZodBoolean>;
+        firedThisLongRest: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        firedThisTurn?: boolean | undefined;
+        firedThisRound?: boolean | undefined;
+        firedThisShortRest?: boolean | undefined;
+        firedThisLongRest?: boolean | undefined;
+    }, {
+        firedThisTurn?: boolean | undefined;
+        firedThisRound?: boolean | undefined;
+        firedThisShortRest?: boolean | undefined;
+        firedThisLongRest?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "TriggerFired";
+    id: string;
+    characterId: string;
+    triggerId: string;
+    cadence: {
+        firedThisTurn?: boolean | undefined;
+        firedThisRound?: boolean | undefined;
+        firedThisShortRest?: boolean | undefined;
+        firedThisLongRest?: boolean | undefined;
+    };
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "TriggerFired";
+    id: string;
+    characterId: string;
+    triggerId: string;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+    cadence?: {
+        firedThisTurn?: boolean | undefined;
+        firedThisRound?: boolean | undefined;
+        firedThisShortRest?: boolean | undefined;
+        firedThisLongRest?: boolean | undefined;
+    } | undefined;
+}>;
+export type TriggerFiredEvent = z.infer<typeof TriggerFiredEventSchema>;
+//# sourceMappingURL=triggers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/triggers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/events/weapon-mastery.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const WeaponMasteryActivatedEventSchema: 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<"WeaponMasteryActivated">;
+    mastery: z.ZodEnum<["Vex", "Topple", "Sap", "Nick", "Push", "Slow", "Cleave", "Graze", "Flex"]>;
+    attackerId: z.ZodString;
+    targetId: z.ZodOptional<z.ZodString>;
+    weaponInstanceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "WeaponMasteryActivated";
+    id: string;
+    mastery: "Vex" | "Topple" | "Sap" | "Nick" | "Push" | "Slow" | "Cleave" | "Graze" | "Flex";
+    weaponInstanceId: string;
+    attackerId: string;
+    targetId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}, {
+    at: string;
+    type: "WeaponMasteryActivated";
+    id: string;
+    mastery: "Vex" | "Topple" | "Sap" | "Nick" | "Push" | "Slow" | "Cleave" | "Graze" | "Flex";
+    weaponInstanceId: string;
+    attackerId: string;
+    targetId?: string | undefined;
+    sessionId?: string | undefined;
+    causedByEventId?: string | undefined;
+    actorId?: string | undefined;
+}>;
+export type WeaponMasteryActivatedEvent = z.infer<typeof WeaponMasteryActivatedEventSchema>;
+//# sourceMappingURL=weapon-mastery.d.ts.map

package/dist/schemas/events/weapon-mastery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weapon-mastery.d.ts","sourceRoot":"","sources":["../../../src/schemas/events/weapon-mastery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC"}

package/dist/schemas/formula.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+declare const ConstNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"const">;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    kind: "const";
+}, {
+    value: number;
+    kind: "const";
+}>;
+declare const AbilityNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"ability">;
+    ability: z.ZodEnum<["STR", "DEX", "CON", "INT", "WIS", "CHA"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "ability";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+}, {
+    kind: "ability";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+}>;
+declare const AbilityModNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"abilityMod">;
+    ability: z.ZodEnum<["STR", "DEX", "CON", "INT", "WIS", "CHA"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "abilityMod";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+}, {
+    kind: "abilityMod";
+    ability: "STR" | "DEX" | "CON" | "INT" | "WIS" | "CHA";
+}>;
+declare const ProfBonusNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"profBonus">;
+}, "strip", z.ZodTypeAny, {
+    kind: "profBonus";
+}, {
+    kind: "profBonus";
+}>;
+declare const LevelNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"level">;
+    classId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "level";
+    classId?: string | undefined;
+}, {
+    kind: "level";
+    classId?: string | undefined;
+}>;
+declare const ClassColumnNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"classCol">;
+    classId: z.ZodString;
+    column: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "classCol";
+    classId: string;
+    column: string;
+}, {
+    kind: "classCol";
+    classId: string;
+    column: string;
+}>;
+declare const DiceNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"dice">;
+    expression: z.ZodString;
+    average: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    kind: "dice";
+    expression: string;
+    average?: boolean | undefined;
+}, {
+    kind: "dice";
+    expression: string;
+    average?: boolean | undefined;
+}>;
+interface AddNode {
+    kind: 'add';
+    terms: Formula[];
+}
+interface MaxNode {
+    kind: 'max';
+    terms: Formula[];
+}
+interface MinNode {
+    kind: 'min';
+    terms: Formula[];
+}
+interface MultiplyNode {
+    kind: 'multiply';
+    terms: Formula[];
+}
+interface FloorNode {
+    kind: 'floor';
+    term: Formula;
+}
+interface CeilNode {
+    kind: 'ceil';
+    term: Formula;
+}
+export type Formula = z.infer<typeof ConstNodeSchema> | z.infer<typeof AbilityNodeSchema> | z.infer<typeof AbilityModNodeSchema> | z.infer<typeof ProfBonusNodeSchema> | z.infer<typeof LevelNodeSchema> | z.infer<typeof ClassColumnNodeSchema> | z.infer<typeof DiceNodeSchema> | AddNode | MaxNode | MinNode | MultiplyNode | FloorNode | CeilNode;
+export declare const FormulaSchema: z.ZodType<Formula>;
+export declare const isFormula: (value: unknown) => value is Formula;
+export {};
+//# sourceMappingURL=formula.d.ts.map

package/dist/schemas/formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../src/schemas/formula.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,eAAe;;;;;;;;;EAGnB,CAAC;AAEH,QAAA,MAAM,iBAAiB;;;;;;;;;EAGrB,CAAC;AAEH,QAAA,MAAM,oBAAoB;;;;;;;;;EAGxB,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;EAEvB,CAAC;AAEH,QAAA,MAAM,eAAe;;;;;;;;;EAGnB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;EAIzB,CAAC;AAEH,QAAA,MAAM,cAAc;;;;;;;;;;;;EAIlB,CAAC;AAEH,UAAU,OAAO;IACf,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,UAAU,OAAO;IACf,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,UAAU,OAAO;IACf,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,UAAU,SAAS;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAED,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,MAAM,OAAO,GACf,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAC/B,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,GACjC,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,GACpC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GACnC,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAC/B,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GACrC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,GAC9B,OAAO,GACP,OAAO,GACP,OAAO,GACP,YAAY,GACZ,SAAS,GACT,QAAQ,CAAC;AAEb,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAkC5C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OACZ,CAAC"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,8 @@
+export * from './primitives.js';
+export * from './formula.js';
+export * from './predicate.js';
+export * from './effects.js';
+export * from './content/index.js';
+export * from './runtime/index.js';
+export * from './events/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}