ttrpg-engine-dnd 0.1.0-alpha.0

package/dist/schemas/runtime/effect-instance.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const AppliedConditionRefSchema: 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;
+}>;
+export type AppliedConditionRef = z.infer<typeof AppliedConditionRefSchema>;
+export declare const EffectInstanceSchema: z.ZodObject<{
+    id: z.ZodString;
+    spellId: z.ZodString;
+    casterId: 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">>;
+    requiresConcentration: z.ZodBoolean;
+    durationRounds: z.ZodOptional<z.ZodNumber>;
+    startedAtEventId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    spellId: string;
+    casterId: string;
+    targetIds: string[];
+    conditionsApplied: {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }[];
+    requiresConcentration: boolean;
+    startedAtEventId: string;
+    durationRounds?: number | undefined;
+}, {
+    id: string;
+    spellId: string;
+    casterId: string;
+    requiresConcentration: boolean;
+    startedAtEventId: string;
+    durationRounds?: number | undefined;
+    targetIds?: string[] | undefined;
+    conditionsApplied?: {
+        conditionId: string;
+        targetId: string;
+        appliedConditionId: string;
+    }[] | undefined;
+}>;
+export type EffectInstance = z.infer<typeof EffectInstanceSchema>;
+//# sourceMappingURL=effect-instance.d.ts.map

package/dist/schemas/runtime/effect-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-instance.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/effect-instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/runtime/encounter.d.ts

@@ -0,0 +1,264 @@
+import { z } from 'zod';
+export declare const EncounterStatusSchema: z.ZodEnum<["planning", "active", "ended"]>;
+export type EncounterStatus = z.infer<typeof EncounterStatusSchema>;
+export declare const PositionSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}>;
+export type Position = z.infer<typeof PositionSchema>;
+export declare const TurnUsageSchema: z.ZodObject<{
+    actionUsed: z.ZodDefault<z.ZodBoolean>;
+    bonusActionUsed: z.ZodDefault<z.ZodBoolean>;
+    attacksMadeThisTurn: z.ZodDefault<z.ZodNumber>;
+    reactionUsedThisRound: z.ZodDefault<z.ZodBoolean>;
+    feetMovedThisTurn: z.ZodDefault<z.ZodNumber>;
+    dashed: z.ZodDefault<z.ZodBoolean>;
+    disengaged: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    actionUsed: boolean;
+    bonusActionUsed: boolean;
+    attacksMadeThisTurn: number;
+    reactionUsedThisRound: boolean;
+    feetMovedThisTurn: number;
+    dashed: boolean;
+    disengaged: boolean;
+}, {
+    actionUsed?: boolean | undefined;
+    bonusActionUsed?: boolean | undefined;
+    attacksMadeThisTurn?: number | undefined;
+    reactionUsedThisRound?: boolean | undefined;
+    feetMovedThisTurn?: number | undefined;
+    dashed?: boolean | undefined;
+    disengaged?: boolean | undefined;
+}>;
+export type TurnUsage = z.infer<typeof TurnUsageSchema>;
+export declare const EMPTY_TURN_USAGE: TurnUsage;
+export declare const CombatantSchema: z.ZodObject<{
+    combatantId: z.ZodString;
+    initiative: z.ZodNumber;
+    initiativeOrder: z.ZodNumber;
+    hasActedThisRound: z.ZodDefault<z.ZodBoolean>;
+    turnUsage: z.ZodDefault<z.ZodObject<{
+        actionUsed: z.ZodDefault<z.ZodBoolean>;
+        bonusActionUsed: z.ZodDefault<z.ZodBoolean>;
+        attacksMadeThisTurn: z.ZodDefault<z.ZodNumber>;
+        reactionUsedThisRound: z.ZodDefault<z.ZodBoolean>;
+        feetMovedThisTurn: z.ZodDefault<z.ZodNumber>;
+        dashed: z.ZodDefault<z.ZodBoolean>;
+        disengaged: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        actionUsed: boolean;
+        bonusActionUsed: boolean;
+        attacksMadeThisTurn: number;
+        reactionUsedThisRound: boolean;
+        feetMovedThisTurn: number;
+        dashed: boolean;
+        disengaged: boolean;
+    }, {
+        actionUsed?: boolean | undefined;
+        bonusActionUsed?: boolean | undefined;
+        attacksMadeThisTurn?: number | undefined;
+        reactionUsedThisRound?: boolean | undefined;
+        feetMovedThisTurn?: number | undefined;
+        dashed?: boolean | undefined;
+        disengaged?: boolean | undefined;
+    }>>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    initiative: number;
+    combatantId: string;
+    initiativeOrder: number;
+    hasActedThisRound: boolean;
+    turnUsage: {
+        actionUsed: boolean;
+        bonusActionUsed: boolean;
+        attacksMadeThisTurn: number;
+        reactionUsedThisRound: boolean;
+        feetMovedThisTurn: number;
+        dashed: boolean;
+        disengaged: boolean;
+    };
+    position?: {
+        x: number;
+        y: number;
+    } | undefined;
+}, {
+    initiative: number;
+    combatantId: string;
+    initiativeOrder: number;
+    hasActedThisRound?: boolean | undefined;
+    turnUsage?: {
+        actionUsed?: boolean | undefined;
+        bonusActionUsed?: boolean | undefined;
+        attacksMadeThisTurn?: number | undefined;
+        reactionUsedThisRound?: boolean | undefined;
+        feetMovedThisTurn?: number | undefined;
+        dashed?: boolean | undefined;
+        disengaged?: boolean | undefined;
+    } | undefined;
+    position?: {
+        x: number;
+        y: number;
+    } | undefined;
+}>;
+export type Combatant = z.infer<typeof CombatantSchema>;
+export declare const EncounterSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["planning", "active", "ended"]>;
+    combatants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        combatantId: z.ZodString;
+        initiative: z.ZodNumber;
+        initiativeOrder: z.ZodNumber;
+        hasActedThisRound: z.ZodDefault<z.ZodBoolean>;
+        turnUsage: z.ZodDefault<z.ZodObject<{
+            actionUsed: z.ZodDefault<z.ZodBoolean>;
+            bonusActionUsed: z.ZodDefault<z.ZodBoolean>;
+            attacksMadeThisTurn: z.ZodDefault<z.ZodNumber>;
+            reactionUsedThisRound: z.ZodDefault<z.ZodBoolean>;
+            feetMovedThisTurn: z.ZodDefault<z.ZodNumber>;
+            dashed: z.ZodDefault<z.ZodBoolean>;
+            disengaged: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            actionUsed: boolean;
+            bonusActionUsed: boolean;
+            attacksMadeThisTurn: number;
+            reactionUsedThisRound: boolean;
+            feetMovedThisTurn: number;
+            dashed: boolean;
+            disengaged: boolean;
+        }, {
+            actionUsed?: boolean | undefined;
+            bonusActionUsed?: boolean | undefined;
+            attacksMadeThisTurn?: number | undefined;
+            reactionUsedThisRound?: boolean | undefined;
+            feetMovedThisTurn?: number | undefined;
+            dashed?: boolean | undefined;
+            disengaged?: boolean | undefined;
+        }>>;
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        initiative: number;
+        combatantId: string;
+        initiativeOrder: number;
+        hasActedThisRound: boolean;
+        turnUsage: {
+            actionUsed: boolean;
+            bonusActionUsed: boolean;
+            attacksMadeThisTurn: number;
+            reactionUsedThisRound: boolean;
+            feetMovedThisTurn: number;
+            dashed: boolean;
+            disengaged: boolean;
+        };
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }, {
+        initiative: number;
+        combatantId: string;
+        initiativeOrder: number;
+        hasActedThisRound?: boolean | undefined;
+        turnUsage?: {
+            actionUsed?: boolean | undefined;
+            bonusActionUsed?: boolean | undefined;
+            attacksMadeThisTurn?: number | undefined;
+            reactionUsedThisRound?: boolean | undefined;
+            feetMovedThisTurn?: number | undefined;
+            dashed?: boolean | undefined;
+            disengaged?: boolean | undefined;
+        } | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }>, "many">>;
+    round: z.ZodNumber;
+    activeIndex: z.ZodNumber;
+    startedAtEventId: z.ZodOptional<z.ZodString>;
+    endedAtEventId: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodEnum<["victory", "defeat", "fled", "parley"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "planning" | "active" | "ended";
+    round: number;
+    id: string;
+    combatants: {
+        initiative: number;
+        combatantId: string;
+        initiativeOrder: number;
+        hasActedThisRound: boolean;
+        turnUsage: {
+            actionUsed: boolean;
+            bonusActionUsed: boolean;
+            attacksMadeThisTurn: number;
+            reactionUsedThisRound: boolean;
+            feetMovedThisTurn: number;
+            dashed: boolean;
+            disengaged: boolean;
+        };
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }[];
+    activeIndex: number;
+    name?: string | undefined;
+    startedAtEventId?: string | undefined;
+    endedAtEventId?: string | undefined;
+    outcome?: "victory" | "defeat" | "fled" | "parley" | undefined;
+}, {
+    status: "planning" | "active" | "ended";
+    round: number;
+    id: string;
+    activeIndex: number;
+    name?: string | undefined;
+    startedAtEventId?: string | undefined;
+    combatants?: {
+        initiative: number;
+        combatantId: string;
+        initiativeOrder: number;
+        hasActedThisRound?: boolean | undefined;
+        turnUsage?: {
+            actionUsed?: boolean | undefined;
+            bonusActionUsed?: boolean | undefined;
+            attacksMadeThisTurn?: number | undefined;
+            reactionUsedThisRound?: boolean | undefined;
+            feetMovedThisTurn?: number | undefined;
+            dashed?: boolean | undefined;
+            disengaged?: boolean | undefined;
+        } | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }[] | undefined;
+    endedAtEventId?: string | undefined;
+    outcome?: "victory" | "defeat" | "fled" | "parley" | undefined;
+}>;
+export type Encounter = z.infer<typeof EncounterSchema>;
+//# sourceMappingURL=encounter.d.ts.map

package/dist/schemas/runtime/encounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/encounter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB,4CAA0C,CAAC;AAC7E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,gBAAgB,EAAE,SAQ9B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/schemas/runtime/in-game-time.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const InGameTimeSchema: z.ZodObject<{
+    totalMinutes: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    totalMinutes: number;
+}, {
+    totalMinutes?: number | undefined;
+}>;
+export type InGameTime = z.infer<typeof InGameTimeSchema>;
+export interface InGameClockBreakdown {
+    readonly days: number;
+    readonly hours: number;
+    readonly minutes: number;
+}
+export declare const breakdownInGameTime: (time: InGameTime) => InGameClockBreakdown;
+export declare const formatInGameTime: (time: InGameTime) => string;
+export declare const advanceInGameTime: (time: InGameTime, minutes: number) => InGameTime;
+//# sourceMappingURL=in-game-time.d.ts.map

package/dist/schemas/runtime/in-game-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-game-time.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/in-game-time.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAM1D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,mBAAmB,GAAI,MAAM,UAAU,KAAG,oBAIrD,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,MAAM,UAAU,KAAG,MAMnD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,UAAU,EAAE,SAAS,MAAM,KAAG,UAGrE,CAAC"}

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

@@ -0,0 +1,15 @@
+export { CharacterSchema, type Character, HPSchema, type HP, DeathSavesSchema, type DeathSaves, ClassEnrollmentSchema, type ClassEnrollment, AppliedConditionSchema, type AppliedCondition, ResourceStateSchema, type ResourceState, computeTotalLevel, } from './character.js';
+export { ItemInstanceSchema, type ItemInstance } from './item-instance.js';
+export { EffectInstanceSchema, AppliedConditionRefSchema, type EffectInstance, type AppliedConditionRef, } from './effect-instance.js';
+export { PendingChoiceSchema, type PendingChoice, ChoiceOptionSchema, type ChoiceOption, } from './pending-choice.js';
+export { CampaignStateSchema, type CampaignState, emptyCampaignState, } from './campaign.js';
+export { EncounterSchema, type Encounter, CombatantSchema, type Combatant, EncounterStatusSchema, type EncounterStatus, } from './encounter.js';
+export { PartySchema, type Party } from './party.js';
+export { LocationSchema, type Location, LocationMapSchema, type LocationMap, DoorSchema, type Door, TerrainKindSchema, type TerrainKind, DoorStateSchema, type DoorState, TERRAIN_KINDS, DOOR_STATES, DEFAULT_CELL_SIZE_FEET, NORMAL_MOVEMENT_COST, DIFFICULT_MOVEMENT_COST, } from './location.js';
+export { QuestSchema, type Quest, QuestObjectiveSchema, type QuestObjective, QuestRewardSchema, type QuestReward, QuestStatusSchema, type QuestStatus, ObjectiveStatusSchema, type ObjectiveStatus, QUEST_STATUSES, OBJECTIVE_STATUSES, } from './quest.js';
+export { VehicleSchema, type Vehicle, VehicleKindSchema, type VehicleKind, VEHICLE_KINDS, } from './vehicle.js';
+export { SessionSchema, type Session, JournalEntrySchema, type JournalEntry, JournalAuthorKindSchema, type JournalAuthorKind, JournalVisibilitySchema, type JournalVisibility, JOURNAL_AUTHOR_KINDS, JOURNAL_VISIBILITIES, } from './session.js';
+export { InGameTimeSchema, type InGameTime, breakdownInGameTime, formatInGameTime, advanceInGameTime, type InGameClockBreakdown, } from './in-game-time.js';
+export { CURRENCY_DENOMINATIONS, type CurrencyDenomination, type Currency, emptyCurrency, totalInCopper, addCurrency, subtractCurrency, } from './currency.js';
+export { CampaignSettingsSchema, type CampaignSettings, defaultCampaignSettings, } from './settings.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,SAAS,EACd,QAAQ,EACR,KAAK,EAAE,EACP,gBAAgB,EAChB,KAAK,UAAU,EACf,qBAAqB,EACrB,KAAK,eAAe,EACpB,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,mBAAmB,EACnB,KAAK,aAAa,EAClB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAClB,kBAAkB,EAClB,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAClB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EACf,KAAK,SAAS,EACd,eAAe,EACf,KAAK,SAAS,EACd,qBAAqB,EACrB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EACL,cAAc,EACd,KAAK,QAAQ,EACb,iBAAiB,EACjB,KAAK,WAAW,EAChB,UAAU,EACV,KAAK,IAAI,EACT,iBAAiB,EACjB,KAAK,WAAW,EAChB,eAAe,EACf,KAAK,SAAS,EACd,aAAa,EACb,WAAW,EACX,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,WAAW,EACX,KAAK,KAAK,EACV,oBAAoB,EACpB,KAAK,cAAc,EACnB,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,WAAW,EAChB,qBAAqB,EACrB,KAAK,eAAe,EACpB,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,aAAa,EACb,KAAK,OAAO,EACZ,iBAAiB,EACjB,KAAK,WAAW,EAChB,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,aAAa,EACb,KAAK,OAAO,EACZ,kBAAkB,EAClB,KAAK,YAAY,EACjB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,KAAK,UAAU,EACf,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,sBAAsB,EACtB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,gBAAgB,GACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,uBAAuB,GACxB,MAAM,eAAe,CAAC"}

package/dist/schemas/runtime/item-instance.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const ItemInstanceSchema: z.ZodObject<{
+    id: z.ZodString;
+    definitionId: z.ZodString;
+    customName: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodDefault<z.ZodNumber>;
+    chargesRemaining: z.ZodOptional<z.ZodNumber>;
+    attuned: z.ZodDefault<z.ZodBoolean>;
+    attunedTo: z.ZodOptional<z.ZodString>;
+    equippedBy: z.ZodOptional<z.ZodString>;
+    containerId: z.ZodOptional<z.ZodString>;
+    acquiredAtEventId: z.ZodOptional<z.ZodString>;
+    identifiedByCharacterIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    maxCharges: z.ZodOptional<z.ZodNumber>;
+    sentient: z.ZodOptional<z.ZodObject<{
+        ego: z.ZodNumber;
+        alignment: z.ZodString;
+        personality: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        alignment: string;
+        ego: number;
+        personality?: string | undefined;
+    }, {
+        alignment: string;
+        ego: number;
+        personality?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    attuned: boolean;
+    definitionId: string;
+    quantity: number;
+    identifiedByCharacterIds: string[];
+    customName?: string | undefined;
+    chargesRemaining?: number | undefined;
+    attunedTo?: string | undefined;
+    equippedBy?: string | undefined;
+    containerId?: string | undefined;
+    acquiredAtEventId?: string | undefined;
+    maxCharges?: number | undefined;
+    sentient?: {
+        alignment: string;
+        ego: number;
+        personality?: string | undefined;
+    } | undefined;
+}, {
+    id: string;
+    definitionId: string;
+    attuned?: boolean | undefined;
+    customName?: string | undefined;
+    quantity?: number | undefined;
+    chargesRemaining?: number | undefined;
+    attunedTo?: string | undefined;
+    equippedBy?: string | undefined;
+    containerId?: string | undefined;
+    acquiredAtEventId?: string | undefined;
+    identifiedByCharacterIds?: string[] | undefined;
+    maxCharges?: number | undefined;
+    sentient?: {
+        alignment: string;
+        ego: number;
+        personality?: string | undefined;
+    } | undefined;
+}>;
+export type ItemInstance = z.infer<typeof ItemInstanceSchema>;
+//# sourceMappingURL=item-instance.d.ts.map

package/dist/schemas/runtime/item-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-instance.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/item-instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schemas/runtime/location.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export declare const TERRAIN_KINDS: readonly ["normal", "difficult", "impassable", "water"];
+export declare const TerrainKindSchema: z.ZodEnum<["normal", "difficult", "impassable", "water"]>;
+export type TerrainKind = z.infer<typeof TerrainKindSchema>;
+export declare const DEFAULT_CELL_SIZE_FEET = 5;
+export declare const NORMAL_MOVEMENT_COST = 1;
+export declare const DIFFICULT_MOVEMENT_COST = 2;
+export declare const LocationMapSchema: z.ZodObject<{
+    widthCells: z.ZodNumber;
+    heightCells: z.ZodNumber;
+    cellSizeFeet: z.ZodDefault<z.ZodNumber>;
+    terrain: z.ZodArray<z.ZodArray<z.ZodEnum<["normal", "difficult", "impassable", "water"]>, "many">, "many">;
+}, "strip", z.ZodTypeAny, {
+    widthCells: number;
+    heightCells: number;
+    cellSizeFeet: number;
+    terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+}, {
+    widthCells: number;
+    heightCells: number;
+    terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+    cellSizeFeet?: number | undefined;
+}>;
+export type LocationMap = z.infer<typeof LocationMapSchema>;
+export declare const DOOR_STATES: readonly ["open", "closed", "locked"];
+export declare const DoorStateSchema: z.ZodEnum<["open", "closed", "locked"]>;
+export type DoorState = z.infer<typeof DoorStateSchema>;
+export declare const DoorSchema: z.ZodObject<{
+    id: z.ZodString;
+    locationId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>;
+    state: z.ZodEnum<["open", "closed", "locked"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    locationId: string;
+    state: "open" | "closed" | "locked";
+    name?: string | undefined;
+}, {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    locationId: string;
+    state: "open" | "closed" | "locked";
+    name?: string | undefined;
+}>;
+export type Door = z.infer<typeof DoorSchema>;
+export declare const LocationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parentLocationId: z.ZodOptional<z.ZodString>;
+    map: z.ZodOptional<z.ZodObject<{
+        widthCells: z.ZodNumber;
+        heightCells: z.ZodNumber;
+        cellSizeFeet: z.ZodDefault<z.ZodNumber>;
+        terrain: z.ZodArray<z.ZodArray<z.ZodEnum<["normal", "difficult", "impassable", "water"]>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        widthCells: number;
+        heightCells: number;
+        cellSizeFeet: number;
+        terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+    }, {
+        widthCells: number;
+        heightCells: number;
+        terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+        cellSizeFeet?: number | undefined;
+    }>>;
+    doorIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    doorIds: string[];
+    map?: {
+        widthCells: number;
+        heightCells: number;
+        cellSizeFeet: number;
+        terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+    } | undefined;
+    description?: string | undefined;
+    parentLocationId?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    map?: {
+        widthCells: number;
+        heightCells: number;
+        terrain: ("normal" | "difficult" | "impassable" | "water")[][];
+        cellSizeFeet?: number | undefined;
+    } | undefined;
+    description?: string | undefined;
+    parentLocationId?: string | undefined;
+    doorIds?: string[] | undefined;
+}>;
+export type Location = z.infer<typeof LocationSchema>;
+//# sourceMappingURL=location.d.ts.map

package/dist/schemas/runtime/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../src/schemas/runtime/location.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa,yDAA0D,CAAC;AACrF,eAAO,MAAM,iBAAiB,2DAAwB,CAAC;AACvD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,WAAW,uCAAwC,CAAC;AACjE,eAAO,MAAM,eAAe,yCAAsB,CAAC;AACnD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/schemas/runtime/party.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const PartySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    memberIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sharedInventory: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    purse: z.ZodDefault<z.ZodObject<{
+        cp: z.ZodDefault<z.ZodNumber>;
+        sp: z.ZodDefault<z.ZodNumber>;
+        ep: z.ZodDefault<z.ZodNumber>;
+        gp: z.ZodDefault<z.ZodNumber>;
+        pp: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        cp: number;
+        sp: number;
+        ep: number;
+        gp: number;
+        pp: number;
+    }, {
+        cp?: number | undefined;
+        sp?: number | undefined;
+        ep?: number | undefined;
+        gp?: number | undefined;
+        pp?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    memberIds: string[];
+    sharedInventory: string[];
+    purse: {
+        cp: number;
+        sp: number;
+        ep: number;
+        gp: number;
+        pp: number;
+    };
+}, {
+    id: string;
+    name: string;
+    memberIds?: string[] | undefined;
+    sharedInventory?: string[] | undefined;
+    purse?: {
+        cp?: number | undefined;
+        sp?: number | undefined;
+        ep?: number | undefined;
+        gp?: number | undefined;
+        pp?: number | undefined;
+    } | undefined;
+}>;
+export type Party = z.infer<typeof PartySchema>;
+//# sourceMappingURL=party.d.ts.map

package/dist/schemas/runtime/party.d.ts.map

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