@ankorcs/protocol 0.0.0-stage → 0.6.1

package/dist/game-events.d.ts

@@ -0,0 +1,2137 @@
+/**
+ * Plugin events use decimal-string SteamIDs, numeric roster teams and `t`, `ct` and `spec` sides.
+ *
+ * `round` is one-based, `timestamp` is Unix milliseconds, and `round_time` is seconds derived from
+ * the engine, rounded to milliseconds. `tick` is the server tick when the event happened, as the
+ * engine's map tick plus its sub-tick fraction. `seq` is the order in which the events were sent.
+ */
+import { z } from 'zod';
+/** A SteamID64 as 17 decimal digits. */
+export declare const SteamId64: z.ZodString;
+/**
+ * The side a player is on.
+ *
+ * - `t`: terrorists, a playing side.
+ * - `ct`: counter-terrorists, a playing side.
+ * - `spec`: spectators and players on no team.
+ */
+export declare const Side: z.ZodEnum<{
+    t: "t";
+    ct: "ct";
+    spec: "spec";
+}>;
+export type Side = z.infer<typeof Side>;
+/**
+ * A playing side, for a field that never holds `spec`.
+ *
+ * - `t`: terrorists.
+ * - `ct`: counter-terrorists.
+ */
+export declare const PlayingSide: z.ZodEnum<{
+    t: "t";
+    ct: "ct";
+}>;
+export type PlayingSide = z.infer<typeof PlayingSide>;
+/** A team of the {@link Roster}, team 1 or team 2, whichever side it plays. */
+export declare const TeamNumber: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+export type TeamNumber = z.infer<typeof TeamNumber>;
+/**
+ * The id of one map's match, which the controller chooses. A series of maps is a grouping that the
+ * controller keeps. The id is a lowercase UUID, because demo file names carry it and case matters
+ * there.
+ */
+export declare const MatchId: z.ZodUUID;
+/**
+ * Why a round ended, as the engine names it. When the engine gives a reason that this list does not
+ * name, the plugin sends `unknown`.
+ */
+export declare const RoundEndReason: z.ZodEnum<{
+    readonly unknown: "unknown";
+    /** The bomb exploded. */
+    readonly target_bombed: "target_bombed";
+    readonly terrorists_escaped: "terrorists_escaped";
+    readonly cts_prevent_escape: "cts_prevent_escape";
+    readonly escaping_terrorists_neutralized: "escaping_terrorists_neutralized";
+    /** The bomb was defused. */
+    readonly bomb_defused: "bomb_defused";
+    /** Every T was killed. */
+    readonly cts_win: "cts_win";
+    /** Every CT was killed. */
+    readonly terrorists_win: "terrorists_win";
+    readonly round_draw: "round_draw";
+    readonly all_hostages_rescued: "all_hostages_rescued";
+    /** Time ran out without the bomb planted. */
+    readonly target_saved: "target_saved";
+    readonly hostages_not_rescued: "hostages_not_rescued";
+    readonly terrorists_not_escaped: "terrorists_not_escaped";
+    readonly game_commencing: "game_commencing";
+    /** The Ts voted to surrender. The map ends after this round. */
+    readonly terrorists_surrender: "terrorists_surrender";
+    /** The CTs voted to surrender. The map ends after this round. */
+    readonly cts_surrender: "cts_surrender";
+    readonly terrorists_planted: "terrorists_planted";
+    readonly cts_reached_hostage: "cts_reached_hostage";
+    readonly survival_win: "survival_win";
+    readonly survival_draw: "survival_draw";
+}>;
+export type RoundEndReason = z.infer<typeof RoundEndReason>;
+/** Spectator slots on a CS2 server, for casters and anyone else who watches from the server. */
+export declare const MAX_SPECTATORS = 2;
+/** Players that a CS2 server holds. The players and spectators of a roster fit in it together. */
+export declare const MAX_SERVER_PLAYERS = 64;
+/** Characters in the longest team name. */
+export declare const MAX_TEAM_NAME_LENGTH = 30;
+/**
+ * The most rounds that `mp_maxrounds` can set for a match, ten times the stock 24. A launch that
+ * asks for more fails validation.
+ */
+export declare const MAX_ROUNDS = 240;
+/** A one-based round number. A map's history holds far fewer than the 1000 it allows. */
+export declare const RoundNumber: z.ZodNumber;
+/** The most health or armor that a player can have, ten times the stock 100. */
+export declare const MAX_HEALTH = 1000;
+/**
+ * The most damage that one hit reports, equal to {@link MAX_HEALTH}, so only overkill past that is
+ * cut.
+ */
+export declare const MAX_DAMAGE = 1000;
+/** Characters in the longest player name. Steam allows 32, which UTF-16 writes in at most 64. */
+export declare const MAX_PLAYER_NAME_CHARS = 64;
+/**
+ * A player's name, cut to up to {@link MAX_PLAYER_NAME_CHARS} characters, without control
+ * characters. Rejected when it holds a lone UTF-16 surrogate.
+ */
+export declare const PlayerName: z.ZodString;
+/** Characters in the longest version string that {@link MapStart | map_start} carries. */
+export declare const MAX_VERSION_CHARS = 128;
+/** Characters in the longest `reason` of a {@link PlayerDisconnect | player_disconnect}. */
+export declare const MAX_DISCONNECT_REASON_CHARS = 64;
+/** Characters in the longest `message` of a {@link PluginLog | log}. */
+export declare const MAX_LOG_MESSAGE_CHARS = 8192;
+/**
+ * The most shots that one player fires in a round, over all their weapons. It is about ten times
+ * the most ammunition that a stock weapon carries, the Negev's 450. A
+ * {@link RoundShots | round_shots} with more fails validation, so the plugin counts no more.
+ */
+export declare const MAX_ROUND_SHOTS = 4096;
+/** One team of a {@link Roster}. */
+export declare const RosterTeam: z.ZodObject<{
+    name: z.ZodString;
+    players: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RosterTeam = z.infer<typeof RosterTeam>;
+/**
+ * The teams and spectators of a match. Each player holds one place on the server, whichever team or
+ * list the player is in.
+ *
+ * Rejected when a SteamID appears twice across both teams and `spectators`, or when they hold more
+ * than {@link MAX_SERVER_PLAYERS} together.
+ */
+export declare const Roster: z.ZodObject<{
+    team1: z.ZodObject<{
+        name: z.ZodString;
+        players: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    team2: z.ZodObject<{
+        name: z.ZodString;
+        players: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    spectators: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Roster = z.infer<typeof Roster>;
+/** A player as the event saw them. */
+declare const PlayerRef: z.ZodObject<{
+    steam_id: z.ZodString;
+    name: z.ZodString;
+    side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+        spec: "spec";
+    }>;
+    team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+}, z.core.$strip>;
+export type PlayerRef = z.infer<typeof PlayerRef>;
+/** A point in the world, in engine units. */
+export declare const WorldPos: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodNumber;
+}, z.core.$strip>;
+export type WorldPos = z.infer<typeof WorldPos>;
+/** Where a player stood, as a {@link WorldPos}, and where the player looked. */
+export declare const PlayerPosition: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodNumber;
+    pitch: z.ZodNumber;
+    yaw: z.ZodNumber;
+}, z.core.$strip>;
+export type PlayerPosition = z.infer<typeof PlayerPosition>;
+/** A {@link PlayerRef} with the position of the player when the event happened. */
+declare const PlayerAt: z.ZodObject<{
+    steam_id: z.ZodString;
+    name: z.ZodString;
+    side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+        spec: "spec";
+    }>;
+    team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    position: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+        pitch: z.ZodNumber;
+        yaw: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlayerAt = z.infer<typeof PlayerAt>;
+/**
+ * A {@link PlayerRef} with the position of the player, for a player who acted in the world when the
+ * event happened, so the position is always known.
+ */
+declare const PlacedPlayer: z.ZodObject<{
+    steam_id: z.ZodString;
+    name: z.ZodString;
+    side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+        spec: "spec";
+    }>;
+    team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+        pitch: z.ZodNumber;
+        yaw: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PlacedPlayer = z.infer<typeof PlacedPlayer>;
+/**
+ * Sent when a map has loaded on the server, as the first event of the map's history.
+ *
+ * The plugin sends one on every load. A workshop map loads twice, and an admin's `changelevel`
+ * loads another map.
+ */
+export declare const MapStart: z.ZodObject<{
+    plugin_version: z.ZodString;
+    framework_version: z.ZodString;
+    server_version: z.ZodString;
+    map_name: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"map_start">;
+}, z.core.$strip>;
+/**
+ * Sent when a player connects after the match leaves warmup.
+ * {@link ControllerGetServerStatus | get_server_status} lists who is on the server during warmup.
+ */
+export declare const PlayerConnect: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    rejected: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_connect">;
+}, z.core.$strip>;
+/** Sent when a player leaves after the match leaves warmup. */
+export declare const PlayerDisconnect: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    reason: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_disconnect">;
+}, z.core.$strip>;
+/** Sent when the knife round begins. */
+export declare const KnifeStart: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"knife_start">;
+}, z.core.$strip>;
+/**
+ * Sent when the knife round ends. When both teams survive, the counts in this event decide the
+ * winner.
+ *
+ * Rejected when a team's health is above {@link MAX_HEALTH} times its players alive.
+ */
+export declare const KnifeEnd: z.ZodObject<{
+    winner_team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    winner_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    team1_alive: z.ZodNumber;
+    team2_alive: z.ZodNumber;
+    team1_health: z.ZodNumber;
+    team2_health: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"knife_end">;
+}, z.core.$strip>;
+/** Sent when the knife round winners choose a side, or run out of time and stay. */
+export declare const SideChoice: z.ZodObject<{
+    team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    choice: z.ZodEnum<{
+        stay: "stay";
+        swap: "swap";
+    }>;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"side_choice">;
+}, z.core.$strip>;
+/**
+ * The rules of a match, as a launch asks for them and as {@link GoingLive | going_live} and
+ * {@link RoundBackup | round_backup} report the server playing them.
+ *
+ * The plugin reads the round settings off the server's cvars. `friendly_fire` comes from the
+ * launch, and Ankor applies it through the damage reductions instead of `mp_friendlyfire`.
+ */
+export declare const MatchRules: z.ZodObject<{
+    max_rounds: z.ZodNumber;
+    overtime: z.ZodBoolean;
+    overtime_max_rounds: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+}, z.core.$strip>;
+export type MatchRules = z.infer<typeof MatchRules>;
+/** Sent when the match goes live, with the round settings that it plays under. */
+export declare const GoingLive: z.ZodObject<{
+    max_rounds: z.ZodNumber;
+    overtime: z.ZodBoolean;
+    overtime_max_rounds: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"going_live">;
+}, z.core.$strip>;
+/**
+ * Characters in the longest backup file that a {@link RoundBackup | round_backup} carries. A 5v5
+ * that runs to 40 rounds writes a file of up to a few hundred KB, and tabs and quotes make it about
+ * 1.4 times that as JSON.
+ */
+export declare const MAX_BACKUP_FILE_CHARS: number;
+/**
+ * What a server needs to play on from the backup of a live round. That is the engine's backup file,
+ * which holds the round, the scores and the money and equipment of every player, and the two things
+ * that the file does not hold.
+ *
+ * A launch carries one as `match.restore`.
+ */
+export declare const RestoreFile: z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    rules: z.ZodObject<{
+        max_rounds: z.ZodNumber;
+        overtime: z.ZodBoolean;
+        overtime_max_rounds: z.ZodNumber;
+        friendly_fire: z.ZodBoolean;
+    }, z.core.$strip>;
+    file: z.ZodString;
+}, z.core.$strip>;
+export type RestoreFile = z.infer<typeof RestoreFile>;
+/**
+ * A live round as it started. It holds the {@link RestoreFile} of the round and where the round
+ * stands in the match, both read off the engine.
+ */
+export declare const RestorePoint: z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    rules: z.ZodObject<{
+        max_rounds: z.ZodNumber;
+        overtime: z.ZodBoolean;
+        overtime_max_rounds: z.ZodNumber;
+        friendly_fire: z.ZodBoolean;
+    }, z.core.$strip>;
+    file: z.ZodString;
+    round: z.ZodNumber;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+}, z.core.$strip>;
+export type RestorePoint = z.infer<typeof RestorePoint>;
+/**
+ * Sent when the server has loaded a round backup, from the `restore` of its launch, from a
+ * {@link ControllerRestoreRound | restore_round}, or from an `mp_backup_restore_load_file` that someone
+ * ran by hand.
+ *
+ * The {@link RoundStart | round_start} that follows plays `round` again. From that
+ * {@link RoundStart | round_start} on, the events of the server replace everything that it sent
+ * for that round and the rounds after it.
+ *
+ * The plugin reads the scores and the side from the engine once the engine has loaded the file. The
+ * plugin refuses a load during the knife round, the side choice, the halftime break and after the
+ * match has ended.
+ */
+export declare const MatchRestored: z.ZodObject<{
+    round: z.ZodNumber;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"match_restored">;
+}, z.core.$strip>;
+export type MatchRestored = z.infer<typeof MatchRestored>;
+/**
+ * Sent as each live round starts. The newest one of a map, with the launch of that map, holds
+ * everything that a restore needs on another node.
+ */
+export declare const RoundBackup: z.ZodObject<{
+    roster: z.ZodObject<{
+        team1: z.ZodObject<{
+            name: z.ZodString;
+            players: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        team2: z.ZodObject<{
+            name: z.ZodString;
+            players: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        spectators: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    rules: z.ZodObject<{
+        max_rounds: z.ZodNumber;
+        overtime: z.ZodBoolean;
+        overtime_max_rounds: z.ZodNumber;
+        friendly_fire: z.ZodBoolean;
+    }, z.core.$strip>;
+    file: z.ZodString;
+    round: z.ZodNumber;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_backup">;
+}, z.core.$strip>;
+/**
+ * A weapon, by the engine's item definition index or, for an item without one, the engine's class
+ * name. Rejected when `id` is a number and `fallback` is not null.
+ */
+export declare const Weapon: z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    fallback: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Weapon = z.infer<typeof Weapon>;
+/**
+ * One kind of item that a player holds: the engine's item definition index as `weapon`, a quantity,
+ * and the unit price in this game build.
+ */
+export declare const InventoryItem: z.ZodObject<{
+    weapon: z.ZodNumber;
+    quantity: z.ZodNumber;
+    unit_value: z.ZodNumber;
+}, z.core.$strip>;
+/** What a player carries. A null inventory means that the plugin could not read the pawn. */
+export declare const PlayerInventory: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        weapon: z.ZodNumber;
+        quantity: z.ZodNumber;
+        unit_value: z.ZodNumber;
+    }, z.core.$strip>>;
+    armor: z.ZodNumber;
+    helmet: z.ZodBoolean;
+    defuse_kit: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Sent when a round begins.
+ *
+ * The same round can begin again with no {@link RoundEnd | round_end} between. The engine restarts
+ * a round that a team leaves before it is decided, as when every player on it disconnects or loses
+ * their connection. The later `round_start` replaces the earlier one, and the round is played
+ * from it.
+ */
+export declare const RoundStart: z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        alive: z.ZodBoolean;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+    }, z.core.$strip>>;
+    carryover: z.ZodNullable<z.ZodObject<{
+        from_round: z.ZodNumber;
+        sampled_tick: z.ZodNumber;
+        players: z.ZodArray<z.ZodObject<{
+            player: z.ZodObject<{
+                steam_id: z.ZodString;
+                name: z.ZodString;
+                side: z.ZodEnum<{
+                    t: "t";
+                    ct: "ct";
+                    spec: "spec";
+                }>;
+                team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strip>;
+            alive: z.ZodBoolean;
+            equipment_value: z.ZodNumber;
+            cash: z.ZodNumber;
+            start_cash: z.ZodNumber;
+            cash_spent: z.ZodNumber;
+            inventory: z.ZodNullable<z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    weapon: z.ZodNumber;
+                    quantity: z.ZodNumber;
+                    unit_value: z.ZodNumber;
+                }, z.core.$strip>>;
+                armor: z.ZodNumber;
+                helmet: z.ZodBoolean;
+                defuse_kit: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_start">;
+}, z.core.$strip>;
+/**
+ * Sent when freeze time ends, as the authoritative list of the players who take part in the round
+ * after reconnects during freeze time.
+ */
+export declare const RoundFreezeEnd: z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        alive: z.ZodBoolean;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_freeze_end">;
+}, z.core.$strip>;
+/**
+ * Sent when buy time closes, `mp_buytime` after freeze time ends, with the equipment value that
+ * each roster team carried, as the sum of the engine's figure for each pawn.
+ *
+ * The plugin reads a player at the last buy-zone exit inside the window, or live at the close while
+ * the player is still in a buy zone. Snapshots at a death or disconnect keep a buy that was made
+ * before the window closes. An earlier buy-zone exit counts for a player who never returned.
+ *
+ * Rejected unless `team1_equipment_value` and `team2_equipment_value` are each the sum of
+ * `equipment_value` over the `players` whose `player.team` is that team.
+ */
+export declare const RoundBuyEnd: z.ZodObject<{
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+        sampled_tick: z.ZodNumber;
+    }, z.core.$strip>>;
+    team1_equipment_value: z.ZodNumber;
+    team2_equipment_value: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_buy_end">;
+}, z.core.$strip>;
+/**
+ * Sent when a round is decided. The last gameplay reports of the round may still follow, and
+ * {@link RoundComplete | round_complete} closes it.
+ */
+export declare const RoundEnd: z.ZodObject<{
+    winner_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    winner_team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    reason: z.ZodEnum<{
+        readonly unknown: "unknown";
+        /** The bomb exploded. */
+        readonly target_bombed: "target_bombed";
+        readonly terrorists_escaped: "terrorists_escaped";
+        readonly cts_prevent_escape: "cts_prevent_escape";
+        readonly escaping_terrorists_neutralized: "escaping_terrorists_neutralized";
+        /** The bomb was defused. */
+        readonly bomb_defused: "bomb_defused";
+        /** Every T was killed. */
+        readonly cts_win: "cts_win";
+        /** Every CT was killed. */
+        readonly terrorists_win: "terrorists_win";
+        readonly round_draw: "round_draw";
+        readonly all_hostages_rescued: "all_hostages_rescued";
+        /** Time ran out without the bomb planted. */
+        readonly target_saved: "target_saved";
+        readonly hostages_not_rescued: "hostages_not_rescued";
+        readonly terrorists_not_escaped: "terrorists_not_escaped";
+        readonly game_commencing: "game_commencing";
+        /** The Ts voted to surrender. The map ends after this round. */
+        readonly terrorists_surrender: "terrorists_surrender";
+        /** The CTs voted to surrender. The map ends after this round. */
+        readonly cts_surrender: "cts_surrender";
+        readonly terrorists_planted: "terrorists_planted";
+        readonly cts_reached_hostage: "cts_reached_hostage";
+        readonly survival_win: "survival_win";
+        readonly survival_draw: "survival_draw";
+    }>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    round_length: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_end">;
+}, z.core.$strip>;
+/**
+ * Sent after every gameplay report of a scored round, its {@link RoundShots | round_shots}
+ * included, before the next round or the map end.
+ */
+export declare const RoundComplete: z.ZodObject<{
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_complete">;
+}, z.core.$strip>;
+/**
+ * What caused damage or a death.
+ *
+ * - `player`: another player dealt it, with a weapon or a grenade.
+ * - `bomb`: the planted bomb exploded.
+ * - `fall`: the victim fell.
+ * - `self`: the victim's own grenade or fire.
+ * - `disconnect`: the victim left the server, which kills a living player.
+ * - `other`: anything else, such as a map's damage trigger or the plugin moving a player to the
+ *   spectators.
+ */
+export declare const DamageCause: z.ZodEnum<{
+    player: "player";
+    bomb: "bomb";
+    fall: "fall";
+    self: "self";
+    disconnect: "disconnect";
+    other: "other";
+}>;
+export type DamageCause = z.infer<typeof DamageCause>;
+/**
+ * Sent when a player dies. Rejected when the `assister` has the `steam_id` of the `victim` or the
+ * `attacker`.
+ */
+export declare const PlayerDeath: z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    assister: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>>;
+    weapon: z.ZodObject<{
+        id: z.ZodNullable<z.ZodNumber>;
+        fallback: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    cause: z.ZodEnum<{
+        player: "player";
+        bomb: "bomb";
+        fall: "fall";
+        self: "self";
+        disconnect: "disconnect";
+        other: "other";
+    }>;
+    headshot: z.ZodBoolean;
+    penetrated: z.ZodNumber;
+    thru_smoke: z.ZodBoolean;
+    no_scope: z.ZodBoolean;
+    attacker_blind: z.ZodBoolean;
+    attacker_in_air: z.ZodBoolean;
+    flash_assist: z.ZodBoolean;
+    friendly_fire: z.ZodBoolean;
+    victim_blind_by: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>>;
+    victim_blind_remaining: z.ZodNumber;
+    victim_equipment_value: z.ZodNumber;
+    victim_grenades_held: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        weapon: z.ZodNumber;
+        quantity: z.ZodNumber;
+        unit_value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_death">;
+}, z.core.$strip>;
+/**
+ * The zero-based id of a grenade within its server, counted in throw order. A server throws far
+ * fewer than a million.
+ */
+export declare const GrenadeId: z.ZodNumber;
+/**
+ * Sent when a player takes damage. Rejected when `health_before` is a number and `health_after` is
+ * above it.
+ */
+export declare const PlayerHurt: z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    weapon: z.ZodObject<{
+        id: z.ZodNullable<z.ZodNumber>;
+        fallback: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    cause: z.ZodEnum<{
+        player: "player";
+        bomb: "bomb";
+        fall: "fall";
+        self: "self";
+        disconnect: "disconnect";
+        other: "other";
+    }>;
+    dmg_health: z.ZodNumber;
+    health_before: z.ZodNullable<z.ZodNumber>;
+    health_after: z.ZodNumber;
+    dmg_armor: z.ZodNumber;
+    hitgroup: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    projectile_impact: z.ZodBoolean;
+    grenade_id: z.ZodNullable<z.ZodNumber>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_hurt">;
+}, z.core.$strip>;
+/** Sent when a flashbang blinds a player. */
+export declare const PlayerBlind: z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    duration: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    grenade_id: z.ZodNullable<z.ZodNumber>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_blind">;
+}, z.core.$strip>;
+/** The engine class name of a grenade. */
+export declare const GrenadeKind: z.ZodEnum<{
+    flashbang: "flashbang";
+    hegrenade: "hegrenade";
+    smokegrenade: "smokegrenade";
+    molotov: "molotov";
+    incgrenade: "incgrenade";
+    decoy: "decoy";
+}>;
+export type GrenadeKind = z.infer<typeof GrenadeKind>;
+/**
+ * How a fire ended.
+ *
+ * - `expired`: the fire burned out, or the round closed on it.
+ * - `extinguished`: a smoke put the fire out.
+ * - `smothered`: the fire grenade landed inside a smoke.
+ */
+export declare const FireEnd: z.ZodEnum<{
+    expired: "expired";
+    extinguished: "extinguished";
+    smothered: "smothered";
+}>;
+export type FireEnd = z.infer<typeof FireEnd>;
+/**
+ * Sent when a grenade leaves a player's hand. Its `grenade_id` identifies the grenade in the events
+ * that follow: its {@link GrenadeDetonate | grenade_detonate} and {@link GrenadeEnd | grenade_end},
+ * and the {@link PlayerHurt | player_hurt} and {@link PlayerBlind | player_blind} that it causes.
+ */
+export declare const GrenadeThrow: z.ZodObject<{
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    grenade: z.ZodEnum<{
+        flashbang: "flashbang";
+        hegrenade: "hegrenade";
+        smokegrenade: "smokegrenade";
+        molotov: "molotov";
+        incgrenade: "incgrenade";
+        decoy: "decoy";
+    }>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_throw">;
+}, z.core.$strip>;
+/**
+ * Sent when a grenade detonates or a fire grenade lights. A grenade that is removed before then
+ * sends none.
+ */
+export declare const GrenadeDetonate: z.ZodObject<{
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    detonate_pos: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_detonate">;
+}, z.core.$strip>;
+/**
+ * Sent when the effect of a grenade is over, because its last entity was removed or the round
+ * closed or reset on it. Every grenade that sent a {@link GrenadeThrow | grenade_throw} sends one
+ * before the {@link RoundComplete | round_complete} of its round. A grenade whose round a restore
+ * cut off sends none; the {@link MatchRestored | match_restored} replaces that round.
+ */
+export declare const GrenadeEnd: z.ZodObject<{
+    round: z.ZodNumber;
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    end_round_time: z.ZodNumber;
+    fire_end: z.ZodNullable<z.ZodEnum<{
+        expired: "expired";
+        extinguished: "extinguished";
+        smothered: "smothered";
+    }>>;
+    extinguished_by: z.ZodNullable<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_end">;
+}, z.core.$strip>;
+/**
+ * The shots that a player fired with one weapon over a round. Rejected unless `shots` equals the
+ * number of `ticks`.
+ */
+export declare const WeaponShots: z.ZodObject<{
+    weapon: z.ZodObject<{
+        id: z.ZodNullable<z.ZodNumber>;
+        fallback: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    shots: z.ZodNumber;
+    ticks: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export type WeaponShots = z.infer<typeof WeaponShots>;
+/** The shots that one player fired over a round. */
+export declare const PlayerShots: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    weapons: z.ZodArray<z.ZodObject<{
+        weapon: z.ZodObject<{
+            id: z.ZodNullable<z.ZodNumber>;
+            fallback: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        shots: z.ZodNumber;
+        ticks: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlayerShots = z.infer<typeof PlayerShots>;
+/**
+ * Sent once for each round when it closes, at halftime, the next {@link RoundStart | round_start}
+ * or the {@link MapEnd | map_end}, with the shots that each player fired over the round.
+ *
+ * A round that starts again with no {@link RoundEnd | round_end}, as described on
+ * {@link RoundStart | round_start}, sends none for the attempt it abandoned. Neither does a round
+ * that a restore cut off, which the {@link MatchRestored | match_restored} replaces.
+ *
+ * `players` lists each player who fired, and is empty when nobody did. The plugin counts shots
+ * from the engine's `weapon_fire`, up to {@link MAX_ROUND_SHOTS} for each player, and counts no
+ * more. Knives and grenades are left out, because they fire no rounds. A throw arrives as
+ * {@link GrenadeThrow | grenade_throw} instead. Hits are the {@link PlayerHurt | player_hurt}
+ * events of the same round, attacker and weapon.
+ *
+ * Rejected when a player's shots add up to more than {@link MAX_ROUND_SHOTS}, or when a player or a
+ * weapon of a player is listed twice.
+ */
+export declare const RoundShots: z.ZodObject<{
+    round: z.ZodNumber;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        weapons: z.ZodArray<z.ZodObject<{
+            weapon: z.ZodObject<{
+                id: z.ZodNullable<z.ZodNumber>;
+                fallback: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            shots: z.ZodNumber;
+            ticks: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_shots">;
+}, z.core.$strip>;
+/** Sent when a player begins to plant the bomb. */
+export declare const BombBeginPlant: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_begin_plant">;
+}, z.core.$strip>;
+/** Sent when a player abandons a plant. */
+export declare const BombAbortPlant: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_abort_plant">;
+}, z.core.$strip>;
+/** Sent when the bomb is planted. */
+export declare const BombPlanted: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_planted">;
+}, z.core.$strip>;
+/** Sent when a player begins to defuse the bomb. */
+export declare const BombBeginDefuse: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    has_kit: z.ZodBoolean;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_begin_defuse">;
+}, z.core.$strip>;
+/** Sent when a player abandons a defuse. */
+export declare const BombAbortDefuse: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_abort_defuse">;
+}, z.core.$strip>;
+/** Sent when the bomb is defused. */
+export declare const BombDefused: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    time_remaining: z.ZodNumber;
+    has_kit: z.ZodBoolean;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_defused">;
+}, z.core.$strip>;
+/** Sent when the bomb explodes. */
+export declare const BombExploded: z.ZodObject<{
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_exploded">;
+}, z.core.$strip>;
+/** Sent when the engine names the MVP of a round. */
+export declare const RoundMvp: z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    reason: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_mvp">;
+}, z.core.$strip>;
+/**
+ * Why a map ended:
+ *
+ * - `played`: the map was played out.
+ * - `ready_timeout`: `ready_timeout_seconds` passed in warmup, before the match started.
+ * - `abandoned`: every rostered player left after the match began, in the knife round, the side
+ *   choice or live play.
+ *
+ * Only a `played` map has a winner. The controller decides what any other end means for the match.
+ */
+export declare const MapEndReason: z.ZodEnum<{
+    played: "played";
+    ready_timeout: "ready_timeout";
+    abandoned: "abandoned";
+}>;
+export type MapEndReason = z.infer<typeof MapEndReason>;
+/** A team's players when the ready deadline passed. */
+export declare const ReadyTeam: z.ZodObject<{
+    connected: z.ZodNumber;
+    ready: z.ZodBoolean;
+}, z.core.$strip>;
+export type ReadyTeam = z.infer<typeof ReadyTeam>;
+/**
+ * Sent when the map is over. After a `played` map, the scoreboard stays up for 60 seconds, then the
+ * server kicks the players, sends its remaining events and quits. After a `ready_timeout`, the
+ * server kicks the players at once.
+ *
+ * Rejected unless `winner_team` is the team with the higher score of a `played` map, or null when
+ * the scores are equal or the map was not played out. Rejected unless `teams` is set for a
+ * `ready_timeout`, with both scores 0, and null otherwise.
+ */
+export declare const MapEnd: z.ZodObject<{
+    reason: z.ZodEnum<{
+        played: "played";
+        ready_timeout: "ready_timeout";
+        abandoned: "abandoned";
+    }>;
+    winner_team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    teams: z.ZodNullable<z.ZodObject<{
+        team1: z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>;
+        team2: z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>;
+        spectators: z.ZodNullable<z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"map_end">;
+}, z.core.$strip>;
+/** Sent when the plugin logs a line worth keeping with the match. */
+export declare const PluginLog: z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strip>;
+/** Any gameplay event. */
+export declare const PluginToControllerMessage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    plugin_version: z.ZodString;
+    framework_version: z.ZodString;
+    server_version: z.ZodString;
+    map_name: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"map_start">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    rejected: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_connect">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    reason: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_disconnect">;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"knife_start">;
+}, z.core.$strip>, z.ZodObject<{
+    winner_team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    winner_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    team1_alive: z.ZodNumber;
+    team2_alive: z.ZodNumber;
+    team1_health: z.ZodNumber;
+    team2_health: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"knife_end">;
+}, z.core.$strip>, z.ZodObject<{
+    team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    choice: z.ZodEnum<{
+        stay: "stay";
+        swap: "swap";
+    }>;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"side_choice">;
+}, z.core.$strip>, z.ZodObject<{
+    max_rounds: z.ZodNumber;
+    overtime: z.ZodBoolean;
+    overtime_max_rounds: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"going_live">;
+}, z.core.$strip>, z.ZodObject<{
+    roster: z.ZodObject<{
+        team1: z.ZodObject<{
+            name: z.ZodString;
+            players: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        team2: z.ZodObject<{
+            name: z.ZodString;
+            players: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        spectators: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    rules: z.ZodObject<{
+        max_rounds: z.ZodNumber;
+        overtime: z.ZodBoolean;
+        overtime_max_rounds: z.ZodNumber;
+        friendly_fire: z.ZodBoolean;
+    }, z.core.$strip>;
+    file: z.ZodString;
+    round: z.ZodNumber;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_backup">;
+}, z.core.$strip>, z.ZodObject<{
+    round: z.ZodNumber;
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"match_restored">;
+}, z.core.$strip>, z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        alive: z.ZodBoolean;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+    }, z.core.$strip>>;
+    carryover: z.ZodNullable<z.ZodObject<{
+        from_round: z.ZodNumber;
+        sampled_tick: z.ZodNumber;
+        players: z.ZodArray<z.ZodObject<{
+            player: z.ZodObject<{
+                steam_id: z.ZodString;
+                name: z.ZodString;
+                side: z.ZodEnum<{
+                    t: "t";
+                    ct: "ct";
+                    spec: "spec";
+                }>;
+                team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strip>;
+            alive: z.ZodBoolean;
+            equipment_value: z.ZodNumber;
+            cash: z.ZodNumber;
+            start_cash: z.ZodNumber;
+            cash_spent: z.ZodNumber;
+            inventory: z.ZodNullable<z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    weapon: z.ZodNumber;
+                    quantity: z.ZodNumber;
+                    unit_value: z.ZodNumber;
+                }, z.core.$strip>>;
+                armor: z.ZodNumber;
+                helmet: z.ZodBoolean;
+                defuse_kit: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_start">;
+}, z.core.$strip>, z.ZodObject<{
+    team1_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        alive: z.ZodBoolean;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_freeze_end">;
+}, z.core.$strip>, z.ZodObject<{
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        equipment_value: z.ZodNumber;
+        cash: z.ZodNumber;
+        start_cash: z.ZodNumber;
+        cash_spent: z.ZodNumber;
+        sampled_tick: z.ZodNumber;
+    }, z.core.$strip>>;
+    team1_equipment_value: z.ZodNumber;
+    team2_equipment_value: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_buy_end">;
+}, z.core.$strip>, z.ZodObject<{
+    winner_side: z.ZodEnum<{
+        t: "t";
+        ct: "ct";
+    }>;
+    winner_team: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    reason: z.ZodEnum<{
+        readonly unknown: "unknown";
+        /** The bomb exploded. */
+        readonly target_bombed: "target_bombed";
+        readonly terrorists_escaped: "terrorists_escaped";
+        readonly cts_prevent_escape: "cts_prevent_escape";
+        readonly escaping_terrorists_neutralized: "escaping_terrorists_neutralized";
+        /** The bomb was defused. */
+        readonly bomb_defused: "bomb_defused";
+        /** Every T was killed. */
+        readonly cts_win: "cts_win";
+        /** Every CT was killed. */
+        readonly terrorists_win: "terrorists_win";
+        readonly round_draw: "round_draw";
+        readonly all_hostages_rescued: "all_hostages_rescued";
+        /** Time ran out without the bomb planted. */
+        readonly target_saved: "target_saved";
+        readonly hostages_not_rescued: "hostages_not_rescued";
+        readonly terrorists_not_escaped: "terrorists_not_escaped";
+        readonly game_commencing: "game_commencing";
+        /** The Ts voted to surrender. The map ends after this round. */
+        readonly terrorists_surrender: "terrorists_surrender";
+        /** The CTs voted to surrender. The map ends after this round. */
+        readonly cts_surrender: "cts_surrender";
+        readonly terrorists_planted: "terrorists_planted";
+        readonly cts_reached_hostage: "cts_reached_hostage";
+        readonly survival_win: "survival_win";
+        readonly survival_draw: "survival_draw";
+    }>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    round_length: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_end">;
+}, z.core.$strip>, z.ZodObject<{
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_complete">;
+}, z.core.$strip>, z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    assister: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>>;
+    weapon: z.ZodObject<{
+        id: z.ZodNullable<z.ZodNumber>;
+        fallback: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    cause: z.ZodEnum<{
+        player: "player";
+        bomb: "bomb";
+        fall: "fall";
+        self: "self";
+        disconnect: "disconnect";
+        other: "other";
+    }>;
+    headshot: z.ZodBoolean;
+    penetrated: z.ZodNumber;
+    thru_smoke: z.ZodBoolean;
+    no_scope: z.ZodBoolean;
+    attacker_blind: z.ZodBoolean;
+    attacker_in_air: z.ZodBoolean;
+    flash_assist: z.ZodBoolean;
+    friendly_fire: z.ZodBoolean;
+    victim_blind_by: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>>;
+    victim_blind_remaining: z.ZodNumber;
+    victim_equipment_value: z.ZodNumber;
+    victim_grenades_held: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        weapon: z.ZodNumber;
+        quantity: z.ZodNumber;
+        unit_value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_death">;
+}, z.core.$strip>, z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodNullable<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    weapon: z.ZodObject<{
+        id: z.ZodNullable<z.ZodNumber>;
+        fallback: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    cause: z.ZodEnum<{
+        player: "player";
+        bomb: "bomb";
+        fall: "fall";
+        self: "self";
+        disconnect: "disconnect";
+        other: "other";
+    }>;
+    dmg_health: z.ZodNumber;
+    health_before: z.ZodNullable<z.ZodNumber>;
+    health_after: z.ZodNumber;
+    dmg_armor: z.ZodNumber;
+    hitgroup: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    projectile_impact: z.ZodBoolean;
+    grenade_id: z.ZodNullable<z.ZodNumber>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_hurt">;
+}, z.core.$strip>, z.ZodObject<{
+    victim: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    attacker: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    duration: z.ZodNumber;
+    friendly_fire: z.ZodBoolean;
+    grenade_id: z.ZodNullable<z.ZodNumber>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"player_blind">;
+}, z.core.$strip>, z.ZodObject<{
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    grenade: z.ZodEnum<{
+        flashbang: "flashbang";
+        hegrenade: "hegrenade";
+        smokegrenade: "smokegrenade";
+        molotov: "molotov";
+        incgrenade: "incgrenade";
+        decoy: "decoy";
+    }>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_throw">;
+}, z.core.$strip>, z.ZodObject<{
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    detonate_pos: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_detonate">;
+}, z.core.$strip>, z.ZodObject<{
+    round: z.ZodNumber;
+    grenade_id: z.ZodNumber;
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    end_round_time: z.ZodNumber;
+    fire_end: z.ZodNullable<z.ZodEnum<{
+        expired: "expired";
+        extinguished: "extinguished";
+        smothered: "smothered";
+    }>>;
+    extinguished_by: z.ZodNullable<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"grenade_end">;
+}, z.core.$strip>, z.ZodObject<{
+    round: z.ZodNumber;
+    players: z.ZodArray<z.ZodObject<{
+        player: z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+            team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        }, z.core.$strip>;
+        weapons: z.ZodArray<z.ZodObject<{
+            weapon: z.ZodObject<{
+                id: z.ZodNullable<z.ZodNumber>;
+                fallback: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            shots: z.ZodNumber;
+            ticks: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_shots">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_begin_plant">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_abort_plant">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    site: z.ZodNullable<z.ZodEnum<{
+        a: "a";
+        b: "b";
+    }>>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_planted">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    has_kit: z.ZodBoolean;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_begin_defuse">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_abort_defuse">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            pitch: z.ZodNumber;
+            yaw: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    time_remaining: z.ZodNumber;
+    has_kit: z.ZodBoolean;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_defused">;
+}, z.core.$strip>, z.ZodObject<{
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"bomb_exploded">;
+}, z.core.$strip>, z.ZodObject<{
+    player: z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+        team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strip>;
+    reason: z.ZodNumber;
+    round: z.ZodNumber;
+    round_time: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"round_mvp">;
+}, z.core.$strip>, z.ZodObject<{
+    reason: z.ZodEnum<{
+        played: "played";
+        ready_timeout: "ready_timeout";
+        abandoned: "abandoned";
+    }>;
+    winner_team: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+    teams: z.ZodNullable<z.ZodObject<{
+        team1: z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>;
+        team2: z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>;
+        spectators: z.ZodNullable<z.ZodObject<{
+            connected: z.ZodNumber;
+            ready: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"map_end">;
+}, z.core.$strip>, z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    timestamp: z.ZodNumber;
+    tick: z.ZodNumber;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strip>], "type">;
+export type PluginToControllerMessage = z.infer<typeof PluginToControllerMessage>;
+export {};