npm - volleyballsimtypes - Versions diffs - 0.0.471 → 0.0.474 - Mend

volleyballsimtypes 0.0.471 → 0.0.474

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (47) hide show

package/dist/esm/src/service/team/schemas/libero-sub.z.d.ts CHANGED Viewed

@@ -4,14 +4,46 @@ export declare const LiberoSubModeSchema: z.ZodEnum<{
     NEVER: "NEVER";
     FATIGUE: "FATIGUE";
     ALWAYS: "ALWAYS";
+    CONDITIONS: "CONDITIONS";
 }>;
 export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         NEVER: "NEVER";
         FATIGUE: "FATIGUE";
         ALWAYS: "ALWAYS";
+        CONDITIONS: "CONDITIONS";
     }>;
     fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+    conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+        points: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>], "type">>>;
+    conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;
 export declare const LiberoSubConfigSchema: z.ZodObject<{
     sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -19,13 +51,75 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
             NEVER: "NEVER";
             FATIGUE: "FATIGUE";
             ALWAYS: "ALWAYS";
+            CONDITIONS: "CONDITIONS";
         }>;
         fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+        conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+            margin: z.ZodNumber;
+            opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+            margin: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+            direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+            points: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+            rotations: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+            set: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, z.core.$strip>], "type">>>;
+        conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
     mode: z.ZodEnum<{
         NEVER: "NEVER";
         FATIGUE: "FATIGUE";
         ALWAYS: "ALWAYS";
+        CONDITIONS: "CONDITIONS";
     }>;
     fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+    conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+        points: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>], "type">>>;
+    conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;

package/dist/esm/src/service/team/schemas/libero-sub.z.js CHANGED Viewed

@@ -1,17 +1,34 @@
 import { z } from 'zod';
 import { EnergyBand } from '../energy-band';
-export const LiberoSubModeSchema = z.enum(['NEVER', 'FATIGUE', 'ALWAYS']);
-// Fields shared by the all-sets config and each per-set config. Unlike a designated sub there is no bench or
-// pinch condition here (the swapped-in player is always the dedicated `secondLibero`), so there is nothing to
-// cross-validate.
+import { ConditionLogicSchema, PinchConditionSchema } from './designated-sub.z';
+export const LiberoSubModeSchema = z.enum(['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']);
+// Fields shared by the all-sets config and each per-set config. The swapped-in player is always the dedicated
+// `secondLibero`, so there is no bench to validate; the CONDITIONS mode reuses the pinch-server condition
+// catalog (PinchConditionSchema, which includes the libero-only PHASE condition) + ALL/ANY logic.
 const liberoSetSubConfigShape = {
     mode: LiberoSubModeSchema,
     // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: z.nativeEnum(EnergyBand).optional()
+    fatigueBand: z.nativeEnum(EnergyBand).optional(),
+    // conditions mode only:
+    conditions: z.array(PinchConditionSchema).optional(),
+    conditionLogic: ConditionLogicSchema.optional()
 };
-export const LiberoSetSubConfigSchema = z.object(liberoSetSubConfigShape);
+// CONDITIONS mode needs at least one condition (mirrors the designated-sub pinch refine).
+function refineConditions(data, ctx) {
+    if (data.mode !== 'CONDITIONS')
+        return;
+    if (data.conditions == null || data.conditions.length === 0) {
+        ctx.addIssue({ code: 'custom', message: 'LIBERO_CONDITIONS_REQUIRE_A_CONDITION', path: ['conditions'] });
+    }
+}
+export const LiberoSetSubConfigSchema = z.object(liberoSetSubConfigShape).superRefine(refineConditions);
 export const LiberoSubConfigSchema = z.object({
     ...liberoSetSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
     sets: z.array(LiberoSetSubConfigSchema).max(5).optional()
+}).superRefine((data, ctx) => {
+    // The flat config is the fallback for any set a partial `sets` array doesn't cover, so validate it whenever
+    // `sets` is absent or covers fewer than 5 sets (each present per-set config is validated by its own schema).
+    if (data.sets == null || data.sets.length < 5)
+        refineConditions(data, ctx);
 });

package/dist/esm/src/service/team/schemas/libero-sub.z.test.js CHANGED Viewed

@@ -1,9 +1,10 @@
 import { describe, it, expect } from '@jest/globals';
 import { LiberoSetSubConfigSchema, LiberoSubConfigSchema, LiberoSubModeSchema } from './libero-sub.z';
 import { EnergyBand } from '../energy-band';
+import { MatchPhase, PinchConditionType } from '../pinch-condition';
 describe('LiberoSubModeSchema', () => {
-    it('accepts NEVER, FATIGUE and ALWAYS', () => {
-        for (const mode of ['NEVER', 'FATIGUE', 'ALWAYS']) {
+    it('accepts NEVER, FATIGUE, ALWAYS and CONDITIONS', () => {
+        for (const mode of ['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']) {
             expect(LiberoSubModeSchema.safeParse(mode).success).toBe(true);
         }
     });
@@ -21,6 +22,36 @@ describe('LiberoSetSubConfigSchema', () => {
     it('rejects an unknown band', () => {
         expect(LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: 'SLEEPY' }).success).toBe(false);
     });
+    it('accepts CONDITIONS with a PHASE condition (serve/receive split)', () => {
+        const res = LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditionLogic: 'ALL',
+            conditions: [{ type: PinchConditionType.PHASE, phase: MatchPhase.RECEIVING }]
+        });
+        expect(res.success).toBe(true);
+    });
+    it('accepts CONDITIONS mixing a pinch condition and a PHASE condition', () => {
+        const res = LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditionLogic: 'ANY',
+            conditions: [
+                { type: PinchConditionType.MIN_OWN_SCORE, score: 20 },
+                { type: PinchConditionType.PHASE, phase: MatchPhase.SERVING }
+            ]
+        });
+        expect(res.success).toBe(true);
+    });
+    it('rejects CONDITIONS mode with no conditions', () => {
+        expect(LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS' }).success).toBe(false);
+        expect(LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS', conditions: [] }).success).toBe(false);
+    });
+    it('rejects an invalid PHASE value', () => {
+        const res = LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditions: [{ type: PinchConditionType.PHASE, phase: 'ATTACKING' }]
+        });
+        expect(res.success).toBe(false);
+    });
 });
 describe('LiberoSubConfigSchema', () => {
     it('accepts a flat config with no per-set overrides', () => {

package/dist/esm/src/service/team/schemas/tactics.z.d.ts CHANGED Viewed

@@ -50,6 +50,9 @@ export declare const TacticsInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
             }, z.core.$strip>], "type">>>;
             conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>>;
@@ -86,6 +89,9 @@ export declare const TacticsInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         starter: z.ZodCustom<Player, Player>;
@@ -98,15 +104,77 @@ export declare const TacticsInputSchema: z.ZodObject<{
                 NEVER: "NEVER";
                 FATIGUE: "FATIGUE";
                 ALWAYS: "ALWAYS";
+                CONDITIONS: "CONDITIONS";
             }>;
             fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+            conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                margin: z.ZodNumber;
+                opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                margin: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                points: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                rotations: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                set: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
+            }, z.core.$strip>], "type">>>;
+            conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>>;
         mode: z.ZodEnum<{
             NEVER: "NEVER";
             FATIGUE: "FATIGUE";
             ALWAYS: "ALWAYS";
+            CONDITIONS: "CONDITIONS";
         }>;
         fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+        conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+            margin: z.ZodNumber;
+            opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+            margin: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+            direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+            points: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+            rotations: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+            set: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, z.core.$strip>], "type">>>;
+        conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>;
     liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
     rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;

package/dist/esm/src/service/team/schemas/team.z.d.ts CHANGED Viewed

@@ -58,6 +58,9 @@ export declare const TeamInputSchema: z.ZodObject<{
                 }, z.core.$strip>, z.ZodObject<{
                     type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                     score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                    phase: z.ZodEnum<typeof import("..").MatchPhase>;
                 }, z.core.$strip>], "type">>>;
                 conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             }, z.core.$strip>>>;
@@ -94,6 +97,9 @@ export declare const TeamInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
             }, z.core.$strip>], "type">>>;
             conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             starter: z.ZodCustom<Player, Player>;
@@ -106,15 +112,77 @@ export declare const TeamInputSchema: z.ZodObject<{
                     NEVER: "NEVER";
                     FATIGUE: "FATIGUE";
                     ALWAYS: "ALWAYS";
+                    CONDITIONS: "CONDITIONS";
                 }>;
                 fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
+                conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                    margin: z.ZodNumber;
+                    opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                    margin: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                    direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                    points: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                    rotations: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                    set: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                    phase: z.ZodEnum<typeof import("..").MatchPhase>;
+                }, z.core.$strip>], "type">>>;
+                conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             }, z.core.$strip>>>;
             mode: z.ZodEnum<{
                 NEVER: "NEVER";
                 FATIGUE: "FATIGUE";
                 ALWAYS: "ALWAYS";
+                CONDITIONS: "CONDITIONS";
             }>;
             fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
+            conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                margin: z.ZodNumber;
+                opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                margin: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                points: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                rotations: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                set: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
+            }, z.core.$strip>], "type">>>;
+            conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>;
         liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
         rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.471",
+  "version": "0.0.474",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",