@sagl/server 0.0.0-stage → 0.1.0-next.49

package/dist/server.d.ts

@@ -0,0 +1,713 @@
+import { type WeaponViolationReason } from "./native.js";
+import { Player, type Vector3 } from "./player.js";
+import { Vehicle } from "./vehicle.js";
+import { Ped, type PedSettings } from "./ped.js";
+import { Garage, Zone } from "./zone.js";
+import { Actions } from "./actions.js";
+import { CullZone, World, type Population, type TrafficLights } from "./world.js";
+import { Console } from "./console.js";
+import { GameMap, type MapColor } from "./map.js";
+import { GangZone, type GangZoneArea } from "./gangzones.js";
+import { ServerDraw } from "./draw.js";
+import { Missions, type MissionEvent } from "./mission.js";
+import { PayNSpray } from "./paynspray.js";
+import type { Livery, PaintFinish } from "./paint.js";
+import { ScreenEffects } from "./screeneffects.js";
+import { VehicleColors } from "./vehiclecolors.js";
+import { ModShops } from "./modshop.js";
+import { CutscenePlay, type CutsceneOptions } from "./cutscene.js";
+import { Interactions } from "./interaction.js";
+import { ServerAudio } from "./audio.js";
+import { ServerEffects } from "./effects.js";
+import { Claims } from "./claims.js";
+import { Commands } from "./commands.js";
+/** How chat lines go out (`server.chat`). */
+export interface ChatOptions {
+    /** A line as everyone sees it. Default: "Name: text", the name in `player.color`. `{RRGGBB}` colours a part. */
+    format: (player: Player, text: string) => string;
+    /** The flood limit: a burst of this many lines... */
+    floodLines: number;
+    /** ...then this many a second. */
+    floodPerSecond: number;
+}
+import { ServerAnimations } from "./animations.js";
+import { ServerModels } from "./models.js";
+import { type GameObject, type Pickup, type Label, type LabelTarget, type LabelOptions, type ObjectOptions, type PickupOptions, type Rotation } from "./objects.js";
+import { Channel, ClientScripts, type ChannelData, type ClientScriptError } from "./scripts.js";
+/** How name tags show: see `server.nameTags`. */
+export interface NameTagOptions {
+    distance?: number;
+    lineOfSight?: boolean;
+    ids?: boolean;
+    bars?: boolean;
+}
+export interface ServerOptions {
+    /** UDP port. Default 7777. */
+    port?: number;
+    /** Shown to players when they join. */
+    name?: string;
+    /** Player slots. Default 32. */
+    maxPlayers?: number;
+    /** Money each player starts with. Default 0. */
+    startMoney?: number;
+    /**
+     * Players walk and run like their skin (true) or like CJ (false, the
+     * default); holding a gun, like CJ either way. `player.skinAnimations`
+     * changes it per player.
+     */
+    skinAnimations?: boolean;
+    /**
+     * The game's own entrances (yellow door markers into its interiors)
+     * work. Default true. Off, only the server puts players in interiors
+     * (`player.interior`), as SA-MP's DisableInteriorEnterExits. On, a player
+     * walking through one fires `playerInterior`.
+     */
+    gameEntrances?: boolean;
+    /**
+     * Players' loading screen stays up after they join, as a splash screen
+     * (their game's sound muted), until you hide it (`player.splash.hide()`):
+     * set the scene behind it first (where they are, the camera, the HUD).
+     * `timeoutMs` (default 30000) hides it anyway if you haven't, with a
+     * warning. Default off: it goes as they spawn.
+     */
+    splash?: boolean | {
+        timeoutMs?: number;
+    };
+    /**
+     * Players can pull each other out of vehicles, as SA-MP's (and the
+     * game's): `playerCarjack` hears it. Default true.
+     */
+    carjacking?: boolean;
+    /**
+     * Vehicles' indicators: `keys` gives drivers theirs (`,` left, `.` right,
+     * `;` hazards by default, rebound in Settings, Controls; default true), `autoCancel` turns them off after the turn
+     * as a real stalk does (default true), `sound` is the driver's tick: a
+     * client file, or false for none (default: the built-in one).
+     * `vehicle.indicators` sets them whatever this says.
+     */
+    indicators?: {
+        keys?: boolean;
+        autoCancel?: boolean;
+        sound?: string | false;
+    };
+    /** World 0's weather (`Weather`), default `Weather.SunnyLA`. */
+    weather?: number;
+    /** In-game time at startup. Default 12:00, frozen. */
+    time?: {
+        hour: number;
+        minute: number;
+        frozen?: boolean;
+    };
+    /**
+     * Proxy mode: players may only connect through these proxies (IP
+     * addresses), and the player IP each proxy forwards is trusted. Leave out
+     * for players connecting directly.
+     */
+    trustedProxies?: string[];
+    /** How often the network is serviced, in ms. Default 5. */
+    tickMs?: number;
+    /**
+     * A directory whose files players download when they join (behind a
+     * loading screen) and keep: rejoining, they fetch only what changed, and
+     * delete what's gone. Client scripts, map overlays and script UI can use
+     * them by path (`"ui/shop.rml"`), so they aren't sent again and again.
+     * Paths: letters, digits, `. _ -` and `/`; files up to 64 MB.
+     */
+    clientFiles?: string;
+    /** How the server looks to joining players: see `Branding`. */
+    branding?: Branding;
+}
+/**
+ * The server's look, sent to players first thing as they join: the loading
+ * screen shows the logo (while the other client files download) and the
+ * server's name, and SAGL's menus take the colours.
+ */
+export interface Branding {
+    /**
+     * A client file (see `clientFiles`): a square PNG or JPEG of up to 1 MB,
+     * e.g. `"branding/logo.png"` (256x256 is plenty).
+     */
+    logo?: string;
+    /** A client file shown behind the loading screen (PNG or JPG), covering it. */
+    background?: string;
+    /**
+     * The loading screen shows the server's name beside the logo. Default
+     * false: the logo stands in for the name.
+     */
+    showName?: boolean;
+    /** Replaces the light blue of menu items, headings and bars: `"#RRGGBB"` or 0xRRGGBBAA. */
+    primary?: MapColor;
+    /** Replaces the dark blue behind focused items and slider tracks. */
+    secondary?: MapColor;
+}
+export type QuitReason = "quit" | "timeout" | "kicked";
+export interface VehicleOptions {
+    /** From the game's palette (0-126); random if left out. */
+    colors?: [number, number];
+    /**
+     * Radio station (`RadioStation`). Left out, the first person in it gets
+     * what the game picks for that model (K-Rose in a country pickup, ...).
+     */
+    radio?: number;
+    /** Virtual world. Default 0. */
+    world?: number;
+    /**
+     * Treated as traffic: removed when no player is near (or a while after it
+     * is wrecked), unless it is someone's last car, and faded in and out.
+     */
+    ambient?: boolean;
+    /**
+     * Seconds after it is wrecked, or left empty away from where it was
+     * created, that it is put back there new (`vehicleRespawn`), once nobody
+     * is near enough to see. Left out: never (destroy it yourself).
+     */
+    respawnDelay?: number;
+    /**
+     * Licence plate: up to 8 of A-Z, 0-9 and spaces. Left out: a random one,
+     * as the game makes them (the same for everyone).
+     */
+    plate?: string;
+}
+/** Ambient population a player's game proposed (`populationSpawn`). */
+export interface AmbientSpawn {
+    /** The vehicle model, or null for a ped on foot. */
+    vehicle: number | null;
+    position: Vector3;
+    /** Degrees. */
+    heading: number;
+    /** The ped on foot, or the vehicle's occupants (seat 0 driver). pedType is ePedType. */
+    peds: {
+        model: number;
+        pedType: number;
+        weapon: number;
+        seat: number;
+    }[];
+}
+export interface PedOptions {
+    /** Virtual world. Default 0. */
+    world?: number;
+    /** `Weapon` in its hand. Default unarmed. */
+    weapon?: number;
+    /** Default 100. */
+    health?: number;
+    /**
+     * What it does when nothing is happening: "stand" (the default) where it
+     * was created, or "wander" around. Either way it reacts to what happens
+     * around it as any ped would.
+     */
+    behaviour?: "stand" | "wander";
+    /**
+     * A mission character: `PedSettings`, starting from `{ reactions:
+     * "self-defence", keepTask: true }` (it ignores gunfire and keeps to its
+     * orders, but fights back). Left out: it behaves as the game's peds of its
+     * kind. `ped.set()` changes them later.
+     */
+    mission?: PedSettings | true;
+    /** Who sees it: see `ped.visibleTo`. Default `"world"`. */
+    visibleTo?: readonly Player[] | "world";
+    /** Whose game runs it: see `ped.controller`. Default: the nearest player's. */
+    controller?: Player;
+}
+/**
+ * Something that hit a vehicle: it crashed into something, or a weapon hit
+ * it. Reported by the game simulating the vehicle (its driver's, or a
+ * nearby player's for an empty one).
+ */
+export interface VehicleHit {
+    /** `"collision"`: it crashed into something (or something into it). `"weapon"`: bullets, fire, explosions. */
+    cause: "collision" | "weapon";
+    /**
+     * What it hit, or what hit it: `"vehicle"`, `"ped"` (a player or a ped),
+     * `"object"` (doors, fences, lamp posts...), `"world"` (walls, buildings),
+     * `"ground"` (only when landing did harm); null for a weapon with no owner.
+     */
+    with: "world" | "ground" | "vehicle" | "ped" | "object" | null;
+    /** `Weapon`, or 49 (rammed) for a crash. */
+    weapon: number;
+    /** The other vehicle, if it was one of the server's. */
+    vehicle: Vehicle | null;
+    /** The player involved: the one it hit, the other vehicle's driver, or the shooter. */
+    player: Player | null;
+    /** The server ped involved, the same way. */
+    ped: Ped | null;
+    /** Its health before the hit. */
+    healthBefore: number;
+    /** Its health after (the same if the hit did no harm). */
+    health: number;
+    /** What the hit cost in health. */
+    loss: number;
+    /** How hard: the game's measure of a crash's impact, or a weapon's damage. */
+    intensity: number;
+    position: Vector3;
+}
+/** A shot a player fired, as checked by the server. */
+export interface Shot {
+    /** `Weapon`. */
+    weapon: number;
+    /** Muzzle and aim point. */
+    origin: Vector3;
+    target: Vector3;
+}
+/** An explosion a player caused, matched to something they threw or fired. */
+export interface Explosion {
+    /** eExplosionType: 0 grenade, 1 molotov, 2 rocket, 4 car, ... */
+    type: number;
+    /** The `Weapon` whose projectile went off; 0 for a vehicle they wrecked. */
+    weapon: number;
+    /** The vehicle that blew up, if it was one of the server's. */
+    vehicle: Vehicle | null;
+    position: Vector3;
+}
+/** A hit the server has validated, before it is applied. */
+export interface Hit {
+    /** eWeaponType: 0 unarmed, 22 pistol, 31 M4, ... */
+    weapon: number;
+    /** ePedPieceTypes: 3 torso, 4 groin, 5/6 arms, 7/8 legs, 9 head. */
+    bodyPart: number;
+    /** Damage before the victim's armour is applied. */
+    damage: number;
+    /** Side of the victim that was hit, 0-3. */
+    direction: number;
+    /**
+     * Kills outright whatever the victim's health: a headshot on a ped, as
+     * the shooter's game decided it (always with a sniper or rifle). Returning
+     * a damage number replaces this with exactly that damage.
+     */
+    lethal?: boolean;
+}
+/**
+ * Event handlers. Handlers are called synchronously from the network loop.
+ * They may be async, but only `playerDamage` uses a return value, and it must
+ * return synchronously to count.
+ */
+export interface ServerEvents {
+    /** A player finished joining. Everyone else has already been told. */
+    playerJoin: (player: Player) => void | Promise<void>;
+    /** A player left. The Player object is disconnected after this. */
+    playerQuit: (player: Player, reason: QuitReason) => void | Promise<void>;
+    /**
+     * `attacker` hit `victim` (as the attacker's game saw it, validated by the
+     * server). Return false to cancel the hit, or a number to replace its damage.
+     */
+    playerDamage: (victim: Player, attacker: Player | Ped, hit: Hit) => boolean | number | void;
+    /** The player died. `killer` is whoever last hit them within 10 s. */
+    playerDeath: (player: Player, killer: Player | Ped | null, weapon: number) => void | Promise<void>;
+    /** The player is alive in the world: after joining, and after each respawn. */
+    playerSpawn: (player: Player) => void | Promise<void>;
+    /**
+     * The player opened/closed the pause menu, or their game window lost/gained
+     * focus. Their character stays in the world either way.
+     */
+    playerPause: (player: Player, paused: boolean, focused: boolean) => void | Promise<void>;
+    /**
+     * A chat line from them (not a /command). Return false to drop it, or a
+     * string to send instead of their text; otherwise it goes to everyone as
+     * `server.chat.format` makes it ("Name: text").
+     */
+    playerChat: (player: Player, text: string) => boolean | string | void;
+    /**
+     * A /command line no registered command (`server.commands`) is called:
+     * the whole line, as SA-MP's OnPlayerCommandText. Return true if you
+     * handled it; otherwise they're told it's an unknown command.
+     */
+    playerCommandText: (player: Player, text: string) => boolean | void;
+    /** They came into their checkpoint (`player.setCheckpoint`). */
+    playerEnterCheckpoint: (player: Player) => void | Promise<void>;
+    /** They left it. */
+    playerLeaveCheckpoint: (player: Player) => void | Promise<void>;
+    /** They came into their race checkpoint (`player.setRaceCheckpoint`). */
+    playerEnterRaceCheckpoint: (player: Player) => void | Promise<void>;
+    /** They left it. */
+    playerLeaveRaceCheckpoint: (player: Player) => void | Promise<void>;
+    /**
+     * Their client script put an object in their hands (`model`), or took
+     * one away (`model` null), in `slot`. Return false to refuse: only they
+     * see it, until the slot is set again. Must return synchronously.
+     */
+    playerAttachObject: (player: Player, slot: number, model: number | null) => boolean | void;
+    /**
+     * `jacker` is pulling `victim` out of `vehicle` (carjacking on): as it
+     * starts. The jacker sits there once the victim's out.
+     */
+    playerCarjack: (jacker: Player, victim: Player, vehicle: Vehicle) => void | Promise<void>;
+    /** They pressed the key they bound to one of the server's actions (`server.actions`). */
+    playerAction: (player: Player, id: string) => void | Promise<void>;
+    /**
+     * The buttons they hold changed (`Key` bits; `player.keys` is the same):
+     * `keyPressed(keys, old, Key.Sprint)` for one going down. As their syncs
+     * show it, so a tap between two of them still shows (they're latched).
+     */
+    playerKeys: (player: Player, keys: number, old: number) => void | Promise<void>;
+    /** Their game took them into another interior by itself (one of the game's entrances, when on). */
+    playerInterior: (player: Player, interior: number, old: number) => void | Promise<void>;
+    /** The player got into a vehicle, as driver or passenger (`player.seat`). */
+    playerEnterVehicle: (player: Player, vehicle: Vehicle) => void | Promise<void>;
+    /** The player got out (or died, left, or it was destroyed). */
+    playerExitVehicle: (player: Player, vehicle: Vehicle) => void | Promise<void>;
+    /**
+     * Someone in the vehicle tuned its radio (it's shared by everyone in it).
+     * Return false to refuse (their radio goes back), or a station to tune to
+     * instead. Must return synchronously. To fix a vehicle's radio, set
+     * `vehicle.radio` (e.g. `RadioStation.Off`) and refuse every change.
+     */
+    vehicleRadio: (player: Player, vehicle: Vehicle, station: number) => boolean | number | void;
+    /**
+     * The vehicle is about to blow up (fire, damage), wrecked by `killer` if
+     * anyone. Return false to save it: it is repaired instead. Must return
+     * synchronously.
+     */
+    vehicleDeath: (vehicle: Vehicle, killer: Player | null) => boolean | void;
+    /**
+     * Something hit the vehicle: a crash (into a vehicle, a ped, an object, a
+     * wall, or the ground when that did harm) or a weapon. Hits from the same
+     * thing within 150 ms come as one. Return false to undo it (its health
+     * and dents are put back), or a number for the health it costs instead.
+     * Must return synchronously.
+     */
+    vehicleHit: (vehicle: Vehicle, hit: VehicleHit) => boolean | number | void;
+    /** It was put back where it was created, new (`respawn()`, or its respawn delay). */
+    vehicleRespawn: (vehicle: Vehicle) => void;
+    /**
+     * `attacker` hit a ped (validated as hits on players are). Return false to
+     * cancel the hit, or a number to replace its damage. Must return
+     * synchronously.
+     */
+    pedDamage: (ped: Ped, attacker: Player | Ped, hit: Hit) => boolean | number | void;
+    /**
+     * How a ped's order goes (`ped.walkTo()`, `ped.sequence()`, ...): a step
+     * done, the order done, or failed. Every ped's, in one place; `ped.on()`
+     * has the same for one ped.
+     */
+    pedOrder: (ped: Ped, info: {
+        orderId: number;
+        step: number;
+        state: "stepDone" | "done" | "failed";
+        reason?: string;
+    }) => void;
+    /** A ped died; `killer` landed the last hit within 10 s, if anyone. */
+    pedDeath: (ped: Ped, killer: Player | Ped | null, weapon: number) => void | Promise<void>;
+    /** A mission started, passed, failed or refused someone, or a player joined or left one: for logs and audits. */
+    missionEvent: (event: MissionEvent) => void | Promise<void>;
+    /**
+     * The game simulating a ped reported something impossible (it moved too
+     * fast, healed, changed weapon...). The report was refused; after a few,
+     * another player's game takes the ped over.
+     */
+    pedViolation: (player: Player, ped: Ped, reason: string) => void | Promise<void>;
+    /**
+     * A player's game proposed ambient population (a ped on foot, or a
+     * vehicle with its occupants), within the world's population settings and
+     * budgets. Return false to refuse it. Must return synchronously.
+     */
+    populationSpawn: (spawn: AmbientSpawn, player: Player) => boolean | void;
+    /**
+     * The player fired one round. Already checked (they own the weapon, have
+     * ammo and aren't firing too fast) and counted. Return false to cancel: no
+     * one else sees the shot and its hits don't count. Must return
+     * synchronously.
+     */
+    playerShoot: (player: Player, shot: Shot) => boolean | void;
+    /**
+     * The player's client used or held a weapon it shouldn't: one the server
+     * didn't give (`notOwned`), with no ammo left (`noAmmo`), or faster than
+     * the weapon fires (`fireRate`), or from somewhere they aren't
+     * (`position`). It was refused either way; this is for logging or
+     * punishing.
+     */
+    playerWeaponViolation: (player: Player, reason: WeaponViolationReason, weapon: number) => void | Promise<void>;
+    /**
+     * The player's game says their crimes (or losing the cops) changed their
+     * wanted level (only where the population's `wanted` is on). Return false
+     * to keep the old level, or a number for another. Must return
+     * synchronously.
+     */
+    playerWantedLevel: (player: Player, level: number, old: number) => boolean | number | void;
+    /**
+     * The player's client scripts sent data on a channel (`sagl.emit`); also
+     * given to that channel's handlers (`server.channel(name).on`).
+     */
+    clientMessage: (player: Player, channel: string, data: ChannelData) => void;
+    /** A client script threw (or failed to run) in the player's game. */
+    clientScriptError: (player: Player, error: ClientScriptError) => void;
+    /**
+     * The player's grenade, molotov, rocket or satchel went off (or a vehicle
+     * they wrecked blew up). Return false to cancel: its blast and fire hurt no
+     * player (everyone's game still shows it). Must return synchronously.
+     */
+    playerExplosion: (player: Player, explosion: Explosion) => boolean | void;
+    /** The player (on foot or driving) went into a zone. */
+    zoneEnter: (player: Player, zone: Zone) => void | Promise<void>;
+    /** The player came out of a zone. */
+    zoneLeave: (player: Player, zone: Zone) => void | Promise<void>;
+    /** The player moved while inside a zone: every position update (~20 a second). */
+    zoneMove: (player: Player, zone: Zone) => void | Promise<void>;
+    /** A Pay 'n' Spray or mod shop gave the player's car new colours (as SA-MP's OnVehicleRespray). */
+    vehicleRespray: (player: Player, vehicle: Vehicle, colors: [number, number]) => void | Promise<void>;
+    /** The player bought a part for their car in a mod shop (as SA-MP's OnVehicleMod). */
+    vehicleMod: (player: Player, vehicle: Vehicle, part: number, price: number) => void | Promise<void>;
+    /** The player bought a paint job (0-2) in a mod shop (as SA-MP's OnVehiclePaintjob). */
+    vehiclePaintjob: (player: Player, vehicle: Vehicle, paintjob: number, price: number) => void | Promise<void>;
+    /** The player bought a paint finish (null: standard paint) for their car in a mod shop. */
+    vehicleFinish: (player: Player, vehicle: Vehicle, finish: PaintFinish | null, price: number) => void | Promise<void>;
+    /** The player bought a licence plate for their car in a mod shop. */
+    vehiclePlate: (player: Player, vehicle: Vehicle, plate: string, price: number) => void | Promise<void>;
+    /** The player drove into a mod shop (`ModShop`; 0: one you made; `site` its id), or out (as SA-MP's OnEnterExitModShop). */
+    modShop: (player: Player, vehicle: Vehicle, shop: number, entered: boolean, site: string) => void | Promise<void>;
+    /** The player bought a livery (null: took it off) for their car in a mod shop. */
+    vehicleLivery: (player: Player, vehicle: Vehicle, livery: Livery | null, price: number) => void | Promise<void>;
+}
+/**
+ * A SAGL server.
+ *
+ * ```ts
+ * const server = new Server({ port: 7777, name: "My server" });
+ * server.on("playerJoin", (p) => server.broadcast(`${p.name} joined`));
+ * server.listen();
+ * ```
+ */
+export declare class Server {
+    #private;
+    readonly options: Readonly<ServerOptions>;
+    /** Operator console on stdin; add commands with `server.console.command()`. */
+    readonly console: Console;
+    /** JavaScript run (sandboxed) in every player's game: see `ClientScripts`. */
+    readonly clientScripts: ClientScripts;
+    /** The pause menu's map, everyone's: see `GameMap`. */
+    readonly map: GameMap;
+    /** Drawing on everyone's screen (players joining later too), SA-MP textdraw style: see `ScreenDraw`. */
+    readonly draw: ServerDraw;
+    /** Missions: starting them, start markers, who's in which. See `Missions`. */
+    readonly missions: Missions;
+    /** Car colours: the game's, and your own (ids 128 up). See `VehicleColors`. */
+    readonly vehicleColors: VehicleColors;
+    /** Full-screen effects (your shaders) on everyone's screen, players joining later too. See `ScreenEffects`. */
+    readonly screenEffects: ScreenEffects;
+    /** The game's Pay 'n' Sprays, on by default. See `PayNSpray`. */
+    readonly payNSpray: PayNSpray;
+    /** The game's mod shops (TransFender, Loco Low Co, Wheel Arch Angels), on by default. See `ModShops`. */
+    readonly modShops: ModShops;
+    /** What players can walk up to and use: vending machines, payphones... See `Interactions`. */
+    readonly interactions: Interactions;
+    /** Things players do with a key they choose (Settings, Controls): see `Actions`. */
+    readonly actions: Actions;
+    /** Sounds from client files, positioned or not: see `ServerAudio`. */
+    readonly audio: ServerAudio;
+    /** The game's particle effects and coloured dust: see `ServerEffects`. */
+    readonly effects: ServerEffects;
+    /** First come, first served: one player at a time holds a thing. See `Claims`. */
+    readonly claims: Claims;
+    /** Chat commands, built as Minecraft's (`command(...)`): see `Commands`. */
+    readonly commands: Commands;
+    /** How chat lines go out, and its flood limit: see `ChatOptions`. */
+    readonly chat: ChatOptions;
+    /** The server's own animation sets (IFP client files): see `ServerAnimations`. */
+    readonly animations: ServerAnimations;
+    /** The server's own models (DFF/TXD client files), as SA-MP's AddSimpleModel: see `ServerModels`. */
+    readonly models: ServerModels;
+    /** Floating text in the world: `server.labels.add(text, at, options)`. See `Label`. */
+    readonly labels: {
+        add(text: string, at: LabelTarget, options?: LabelOptions): Label;
+    };
+    constructor(options?: ServerOptions);
+    /** Protocol version clients must speak. */
+    static get protocolVersion(): number;
+    /** SAGL's version this server is (as the client and the SDK: one version for all of SAGL). */
+    static get version(): string;
+    /**
+     * Starts accepting players. Also starts the operator console unless
+     * `{ console: false }`, and stops cleanly on SIGINT/SIGTERM.
+     */
+    listen({ console: withConsole }?: {
+        console?: boolean;
+    }): this;
+    /** Disconnects everyone and stops the network. */
+    close(): void;
+    /** The server's branding, for players joining from now. */
+    get branding(): Branding;
+    set branding(b: Branding);
+    /** What players download from the `clientFiles` directory: path, size, SHA-256 (hex). */
+    get clientFiles(): {
+        path: string;
+        size: number;
+        sha256: string;
+    }[];
+    /**
+     * Reads the `clientFiles` directory again (after changing it); players
+     * joining from now get it as it is. Returns how many files there are.
+     */
+    rescanClientFiles(): number;
+    /**
+     * The named channel between the gamemode and its client scripts (made on
+     * first use): `.on((player, data) => ...)` for what scripts send,
+     * `.send(player, data)` / `.broadcast(data)` to them. Data is JSON.
+     */
+    channel(name: string): Channel;
+    on<E extends keyof ServerEvents>(event: E, listener: ServerEvents[E]): this;
+    off<E extends keyof ServerEvents>(event: E, listener: ServerEvents[E]): this;
+    /**
+     * How name tags show, for everyone: within `distance` m (default 70),
+     * hidden behind buildings and objects (`lineOfSight`, default true), with
+     * their id (`ids`, default true), with health and armour bars under them
+     * (`bars`, default false). Setting it sets what's given. Each player's own:
+     * `player.nameTag`.
+     */
+    get nameTags(): Required<NameTagOptions>;
+    set nameTags(options: NameTagOptions);
+    /**
+     * A gang zone: a coloured rectangle on the radar and maps (SA-MP's
+     * GangZoneCreate), shown to no one until `show()`. See `GangZone`.
+     */
+    createGangZone(area: GangZoneArea, color: MapColor): GangZone;
+    /** Every gang zone not destroyed. */
+    get gangZones(): GangZone[];
+    /**
+     * The game's stunt bonuses for everyone (EnableStuntBonusForAll), players
+     * joining later too; `player.stuntBonus` changes one player's.
+     */
+    get stuntBonus(): boolean;
+    set stuntBonus(on: boolean);
+    /** Connected players. */
+    get players(): Player[];
+    player(id: number): Player | undefined;
+    /**
+     * Shows a message to every player. `color` is 0xRRGGBB. `markdown`: the
+     * text is markdown (bold, italic, code, links). `{key:ID}` shows an
+     * action's key either way.
+     */
+    broadcast(text: string, color?: number, options?: {
+        markdown?: boolean;
+    }): void;
+    /**
+     * An explosion at a spot, as SA-MP's CreateExplosion: the game's own
+     * (`ExplosionType`: grenade, molotov, rocket, car, small, tiny...), its
+     * blast, fire and damage, in the games of `to` (default everyone). It's
+     * no one's: a player it hurts is hurt as by a fall (no attacker), and a
+     * vehicle it wrecks is wrecked by nobody.
+     */
+    createExplosion(position: Vector3, type?: number, options?: {
+        to?: readonly Player[];
+    }): void;
+    /** Empties everyone's chat log. */
+    clearChat(): void;
+    /** A random valid ped model. */
+    randomSkin(): number;
+    /**
+     * Creates a vehicle for everyone, standing on the ground at `position`.
+     * `heading` in degrees (0 = north, anticlockwise).
+     */
+    createVehicle(model: number, position: Vector3, heading?: number, options?: VehicleOptions): Vehicle;
+    /**
+     * Creates a ped standing at `position` (feet) facing `heading` degrees:
+     * a ped model (skin), or one of the story's characters by name ("ryder",
+     * "sweet", "smoke", "cesar"...), which each player's game loads (up to 10
+     * different ones near a player at once).
+     * The nearest player's game runs its AI.
+     */
+    createPed(model: number | string, position: Vector3, heading?: number, options?: PedOptions): Ped;
+    /** Removes a ped for everyone (same as `ped.destroy()`). */
+    destroyPed(ped: Ped): void;
+    /** Every ped, the ambient population's included. */
+    get peds(): Ped[];
+    /** A ped by id. */
+    ped(id: number): Ped | undefined;
+    /** Removes a vehicle for everyone (same as `vehicle.destroy()`). */
+    destroyVehicle(vehicle: Vehicle): void;
+    /** Every vehicle, the ambient traffic's included. */
+    get vehicles(): Vehicle[];
+    vehicle(id: number): Vehicle | undefined;
+    /**
+     * World 0's ambient population (and every world's without its own): see
+     * `world.population`. Off by default.
+     */
+    get population(): Population;
+    set population(settings: Partial<Population>);
+    /**
+     * Watches an area: a sphere (`{ center, radius }`) or an axis-aligned box
+     * between two corners (`{ min, max }`).
+     */
+    createZone(shape: ({
+        center: Vector3;
+        radius: number;
+    } | {
+        min: Vector3;
+        max: Vector3;
+    }) & {
+        /** Only players in this virtual world trigger it. Default: any world. */
+        world?: number;
+    }): Zone;
+    destroyZone(zone: Zone): void;
+    get zones(): Zone[];
+    /** The game's garages, by id. */
+    get garages(): readonly Garage[];
+    garage(id: number): Garage | undefined;
+    /**
+     * Lets players in `viewer` world see (not meet) players and vehicles in
+     * `target` world, one way: a safehouse world viewing world 0 sees the
+     * street; world 0 still doesn't see in.
+     */
+    /**
+     * One of the game's objects (any object model: crates, gates, barriers,
+     * switches...) where you put it, for everyone (or `visibleTo`). It stays
+     * put: players' games never push or break it. With `health` it's
+     * breakable: players' shots, blows and cars wear it down until it's
+     * destroyed (`onDestroyed`). `move()` glides it (gates, shutters).
+     */
+    createObject(model: number, position: Vector3, rotation?: Rotation, options?: ObjectOptions): GameObject;
+    /**
+     * A pickup, spinning and glowing as the game's: a weapon (`weapon`,
+     * `ammo`), `health`, `armour` or `money`, given when a player walks into
+     * it (checked by the server), or any `model` with `onPickup` doing the
+     * rest. Taken once, or back after `respawn` ms.
+     */
+    createPickup(options: PickupOptions): Pickup;
+    /**
+     * Plays one of the game's cutscenes (from `anim/cuts.img`, e.g.
+     * `"ryder2a"`) for these players together: each game loads it (their
+     * screens fade out), it starts for everyone once all have it, and `done`
+     * resolves when everyone's has finished. The first player is the leader:
+     * their skip ends it for everyone (see `CutsceneOptions`).
+     */
+    playCutscene(players: Player | readonly Player[], name: string, options?: CutsceneOptions): CutscenePlay;
+    setWorldView(viewer: number, target: number, visible?: boolean): void;
+    /** Whether `viewer` world sees `target` world. */
+    worldSees(viewer: number, target: number): boolean;
+    /** A virtual world's settings: its time and weather (world 0's by default). */
+    world(id: number): World;
+    /**
+     * An area with effects like the game's own cull and audio zones, applied by
+     * the games of players in `world` (default: every world): interior music
+     * (`audio`, an `AudioZone`), `attributes` (`ZoneAttribute` bits, e.g. no
+     * rain) and/or a `mirror` (the plane at `coord` across `axis` 0 x / 1 y /
+     * 2 z, facing `sign`). An axis-aligned box between `min` and `max`.
+     */
+    createCullZone(zone: {
+        min: Vector3;
+        max: Vector3;
+        world?: number;
+        audio?: number;
+        attributes?: number;
+        mirror?: {
+            axis: 0 | 1 | 2;
+            sign: 1 | -1;
+            coord: number;
+        };
+    }): CullZone;
+    destroyCullZone(zone: CullZone): void;
+    /** World 0's weather (`Weather`); other worlds follow it unless set apart. */
+    get weather(): number;
+    set weather(weather: number);
+    /** World 0's traffic lights (every world's without its own): see `TrafficLights`. */
+    get trafficLights(): TrafficLights;
+    /** In-game time (world 0's). Setting it keeps the current frozen/running state. */
+    get time(): {
+        hour: number;
+        minute: number;
+        frozen: boolean;
+    };
+    set time(value: {
+        hour: number;
+        minute: number;
+    });
+    freezeTime(): void;
+    unfreezeTime(): void;
+}