@killscript/types 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KILLSCRIPT contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @killscript/types
+
+TypeScript declarations for the verified native KILLSCRIPT Lua API. Client and
+Reflex declarations are available through `@killscript/types/client` and
+`@killscript/types/server`.
+
+The declarations cover the complete public `LuaType`/`LuaGen` surface exposed
+by the current game source metadata. Context-specific globals, mutability,
+optional objects, native one-based arrays and verified runtime caveats are
+represented directly in TypeScript.
+
+Generated projects load the right declaration entry automatically. For manual
+configuration, add one entry to `compilerOptions.types`:
+
+```json
+{ "compilerOptions": { "types": ["@killscript/types/client"] } }
+```
+
+Behavioral documentation and examples live in the
+[verified native API reference](https://silentbless.github.io/killscript-docs/).
+Licensed under MIT.

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import "./shared.js";
+import "./generated/client.js";
+export {};
+declare global {
+    /** Client-only persistent storage. Values are saved when the module unloads. */
+    const Storage: StorageTable;
+    interface InputAction {
+        /**
+         * Disables IsPressed(), but the current game build can still invoke
+         * OnPerformed callbacks. Guard the callback with your own enabled flag when
+         * complete suppression is required.
+         */
+        Disable(): void;
+    }
+}

package/dist/generated/client.d.ts

@@ -0,0 +1,457 @@
+import "./shared.js";
+export {};
+declare global {
+    interface AgentsApi {
+        OnDeath(callback: (event: DeathEvent) => void): EventSubscription;
+        OnLocalPlayerDealtDamage(callback: (event: HitEvent) => void): EventSubscription;
+        OnLocalPlayerReceivedDamage(callback: (event: DamageEvent) => void): EventSubscription;
+    }
+    interface Agent {
+        readonly Avatar: Texture;
+        readonly AvatarIsTeamPlaceholder: boolean;
+        readonly IsSpectated: boolean;
+        TrySpectate(): boolean;
+    }
+    interface Aim {
+        readonly DirectionViewportPoint: Vector3;
+    }
+    interface OcclusionCulling {
+        readonly HasBeenVisible: boolean;
+        readonly TicksSinceLastVisible: number;
+    }
+    interface SoundsApi {
+        GetSound(soundName: string): Sound | undefined;
+        PlaySound(sound: Sound, position: Vector3, volume?: number, minDistance?: number, maxDistance?: number, pitch?: number): void;
+        PlaySound2D(sound: Sound, volume?: number, pitch?: number): void;
+    }
+    type Sounds = SoundsApi;
+    const Sounds: SoundsApi;
+    interface VoiceChatApi {
+        IsAvailable(agent: Agent): boolean;
+        IsMuted(agent: Agent): boolean;
+        IsSpeaking(agent: Agent): boolean;
+        SetMuted(agent: Agent, muted: boolean): boolean;
+        ToggleMuted(agent: Agent): boolean;
+    }
+    type VoiceChat = VoiceChatApi;
+    const VoiceChat: VoiceChatApi;
+    interface VoiceLinePlayerApi {
+        readonly IsPlaying: boolean;
+        readonly Subtitle: string;
+    }
+    type VoiceLinePlayer = VoiceLinePlayerApi;
+    const VoiceLinePlayer: VoiceLinePlayerApi;
+    interface CamerasApi {
+        readonly Main: Camera;
+        CreateCamera(): Camera | undefined;
+        RemoveCamera(camera: Camera): void;
+    }
+    type Cameras = CamerasApi;
+    const Cameras: CamerasApi;
+    interface Camera {
+        Aspect: number;
+        FarClipPlane: number;
+        Fov: number;
+        readonly IsMainCamera: boolean;
+        IsOrthographic: boolean;
+        NearClipPlane: number;
+        OrthographicSize: number;
+        readonly OutputTexture: Texture | undefined;
+        Position: Vector3;
+        Rotation: Quaternion;
+        SetActive(value: boolean): void;
+        SetRenderSize(width: number, height: number): void;
+        WorldToViewportPoint(worldPos: Vector3): Vector3;
+    }
+    type ChatChannelKind = 0 | 1 | 2 | 3 | 4;
+    const ChatChannelKind: {
+        readonly Party: 0;
+        readonly Private: 1;
+        readonly Match: 2;
+        readonly Team: 3;
+        readonly System: 4;
+    };
+    interface ChatManagerApi {
+        readonly MessageLimit: number;
+        AddLocalMessage(text: string): void;
+        GetActiveChannel(): ChatChannel | undefined;
+        GetChannels(): LuaArray<ChatChannel>;
+        GetMessages(): LuaArray<ChatMessage>;
+        OnActiveChannelChanged(callback: () => void): EventSubscription;
+        OnChannelsChanged(callback: () => void): EventSubscription;
+        OnMessagesChanged(callback: () => void): EventSubscription;
+        SendActiveMessage(text: string): boolean;
+        SendMessage(text: string): void;
+        SetActiveChannel(channelId: string): boolean;
+        SetActiveChannelByKind(channelKind: ChatChannelKind): void;
+        SetActiveLocalTeamChannel(): void;
+        ShowMessageContextMenu(messageId: string): void;
+    }
+    type ChatManager = ChatManagerApi;
+    const ChatManager: ChatManagerApi;
+    interface ChatChannel {
+        readonly DisplayName: string;
+        readonly Id: string;
+        readonly IsAvailable: boolean;
+        readonly IsReadOnly: boolean;
+        readonly Kind: ChatChannelKind;
+        readonly KindName: string;
+        readonly Team: Team;
+    }
+    interface ChatMessage {
+        readonly ChannelDisplayName: string;
+        readonly ChannelId: string;
+        readonly ChannelKind: ChatChannelKind;
+        readonly IsLocal: boolean;
+        readonly IsSystem: boolean;
+        readonly MessageId: string;
+        readonly SenderDisplayName: string;
+        readonly SenderUserId: string;
+        readonly Team: Team;
+        readonly Text: string;
+    }
+    interface CombatLogApi {
+        readonly Entries: LuaArray<CombatLogEntry>;
+    }
+    type CombatLog = CombatLogApi;
+    const CombatLog: CombatLogApi;
+    interface CombatLogEntry {
+        readonly BodyPart: EHitboxBodyPart;
+        readonly Damage: number;
+        readonly Distance: number;
+        readonly Instigator: Agent;
+        readonly IsFatal: boolean;
+        readonly IsOutgoing: boolean;
+        readonly ItemId: number;
+        readonly Tick: number;
+        readonly Victim: Agent;
+        readonly WasShieldDestroyed: boolean;
+        readonly WasStunned: boolean;
+    }
+    interface DefusalGameApi {
+        readonly IsVictory: boolean;
+    }
+    interface Entity {
+        readonly TicksSinceLastVisible: number;
+    }
+    interface ThrownProjectile {
+        SimulateTrajectory(): LuaArray<Vector3>;
+    }
+    interface NetworkInfoApi {
+        readonly InKBps: number;
+        readonly InPacketLossPercent: number;
+        readonly InterpolationDelayMs: number;
+        readonly OutKBps: number;
+        readonly OutPacketLossPercent: number;
+        readonly Ping: number;
+        readonly RttSeconds: number;
+        readonly ServerTickTimeMs: number;
+        readonly TickTimeMs: number;
+    }
+    type NetworkInfo = NetworkInfoApi;
+    const NetworkInfo: NetworkInfoApi;
+    interface PerformanceApi {
+        readonly AvgFps: number;
+        readonly CpuUsagePercent: number;
+        readonly GpuUsagePercent: number;
+        readonly MaxFrameMs: number;
+    }
+    type Performance = PerformanceApi;
+    const Performance: PerformanceApi;
+    interface ScreenApi {
+        readonly Height: number;
+        readonly Width: number;
+    }
+    type Screen = ScreenApi;
+    const Screen: ScreenApi;
+    /** @noSelf */
+    interface WeaponPreviewApi {
+        GetWeaponPreview(weaponName: string): Texture | undefined;
+        RemoveFromCache(weaponName: string): void;
+    }
+    type WeaponPreview = WeaponPreviewApi;
+    const WeaponPreview: WeaponPreviewApi;
+    interface ImGuiApi {
+        AddImGuiWindow(id: string, title: string, rect: Rect): ImGuiWindow;
+        DrawDebugText(text: string): void;
+        DrawText(text: string, rect: Rect, fontSize?: number, color?: Color | undefined, alignment?: TextAnchor): void;
+        DrawTextPos(text: string, screenPosition: Vector2, fontSize?: number, color?: Color | undefined, alignment?: TextAnchor): void;
+        DrawTexture(texture: Texture, rect?: Rect | undefined): void;
+        DrawTextureColor(texture: Texture, color: Color, rect?: Rect | undefined): void;
+        DrawTextUV(text: string, viewportPosition: Vector2, fontSize?: number, color?: Color | undefined, alignment?: TextAnchor): void;
+    }
+    type ImGui = ImGuiApi;
+    const ImGui: ImGuiApi;
+    interface ImGuiWindow {
+        DrawText(text: string, rect: Rect, fontSize: number, color: Color, alignment?: TextAnchor): void;
+        DrawTexture(texture: Texture, rect?: Rect | undefined): void;
+        DrawTextureColor(texture: Texture, color: Color, rect?: Rect | undefined): void;
+        GetContentRenderSize(): Vector2;
+        SetVisibilityTypes(visibilityTypes: LuaTableData): boolean;
+    }
+    interface InputActionsApi {
+        FindAction(actionName: string): InputAction | undefined;
+    }
+    type InputActions = InputActionsApi;
+    const InputActions: InputActionsApi;
+    interface InputAction {
+        Disable(): void;
+        Enable(): void;
+        IsPressed(): boolean;
+        OnPerformed(func: () => void): void;
+    }
+    interface Drop {
+        PickUp(): void;
+    }
+    interface ThrowableItem {
+        SimulateThrowTrajectory(throwState: EThrowState): LuaArray<Vector3>;
+    }
+    interface LocalizationApi {
+        GetTranslation(term: string): string;
+    }
+    type Localization = LocalizationApi;
+    const Localization: LocalizationApi;
+    interface NotificationControllerApi {
+        OnHint(callback: (event: HintNotificationEvent) => void): EventSubscription;
+        OnNotification(callback: (event: NotificationEvent) => void): EventSubscription;
+        OnViolationNotification(callback: (event: ViolationNotificationEvent) => void): EventSubscription;
+        ShowHint(message: string, duration?: number): void;
+        ShowNotification(message: string, duration: number): void;
+    }
+    type NotificationController = NotificationControllerApi;
+    const NotificationController: NotificationControllerApi;
+    interface PingControllerApi {
+        OnPing(callback: (event: PingEvent) => void): EventSubscription;
+        SetPing(position: Vector3): void;
+    }
+    type PingController = PingControllerApi;
+    const PingController: PingControllerApi;
+    /** @noSelf */
+    interface PhysicsApi {
+        Raycast(origin: Vector3, direction: Vector3, maxDistance: number): RaycastHit;
+        Raycast(origin: Vector3, direction: Vector3): RaycastHit;
+    }
+    type Physics = PhysicsApi;
+    const Physics: PhysicsApi;
+    interface SchedulerApi {
+        OnFrame(callback: () => void): EventSubscription;
+    }
+    interface ShopApi {
+        BuyAndDropItem(itemName: string): void;
+        BuyItem(itemName: string): void;
+        CanSellItem(itemName: string): boolean;
+        HasBoughtItem(itemName: string): boolean;
+        IsBuyLimitReachedForItem(itemName: string): boolean;
+        SellItem(itemName: string): void;
+    }
+    type Shop = ShopApi;
+    const Shop: ShopApi;
+    interface TexturesApi {
+        GetTexture(textureName: string): Texture | undefined;
+    }
+    type Textures = TexturesApi;
+    const Textures: TexturesApi;
+    type BackgroundPositionKeyword = 0 | 1 | 2 | 3 | 4;
+    const BackgroundPositionKeyword: {
+        readonly Left: 0;
+        readonly Center: 1;
+        readonly Right: 2;
+        readonly Top: 3;
+        readonly Bottom: 4;
+    };
+    type BackgroundSizeType = 0 | 1 | 2;
+    const BackgroundSizeType: {
+        readonly Contain: 0;
+        readonly Cover: 1;
+        readonly Auto: 2;
+    };
+    type DisplayStyle = 0 | 1;
+    const DisplayStyle: {
+        readonly Flex: 0;
+        readonly None: 1;
+    };
+    type TextAnchor = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    const TextAnchor: {
+        readonly UpperLeft: 0;
+        readonly UpperCenter: 1;
+        readonly UpperRight: 2;
+        readonly MiddleLeft: 3;
+        readonly MiddleCenter: 4;
+        readonly MiddleRight: 5;
+        readonly LowerLeft: 6;
+        readonly LowerCenter: 7;
+        readonly LowerRight: 8;
+    };
+    type WindowVisibilityType = 0 | 1 | 2;
+    const WindowVisibilityType: {
+        readonly Match: 0;
+        readonly Spectate: 1;
+        readonly Killcam: 2;
+    };
+    interface PlayerRankDisplayApi {
+        BindAgent(agent: Agent, cntAvatarRank: VisualElement, imgRank: VisualElement): void;
+        Clear(cntAvatarRank: VisualElement, imgRank: VisualElement): void;
+    }
+    type PlayerRankDisplay = PlayerRankDisplayApi;
+    const PlayerRankDisplay: PlayerRankDisplayApi;
+    interface UIApi {
+        readonly IsConsoleVisible: boolean;
+        readonly IsCursorUnlocked: boolean;
+        readonly IsExclusiveWindowOpen: boolean;
+        readonly IsWindowOpen: boolean;
+        BlurBackground(element: VisualElement): boolean;
+        BuildFromUxml(path: string, id: string, title: string, anchorMode: string, posX: string, posY: string): VisualElement;
+        BuildFromUxmlAbsolute(path: string): VisualElement;
+        BuildFromUxmlAbsoluteCenter(path: string, id: string, title: string): VisualElement;
+        BuildFromUxmlInteractive(path: string): VisualElement;
+        CloseWindow(element: VisualElement, hideVisual?: boolean): boolean;
+        CreateFromUxml(path: string): VisualElement;
+        CreateLabel(): TextElement;
+        CreateVisualElement(): VisualElement | undefined;
+        Delete(element: VisualElement): boolean;
+        GetMousePosition(): Vector2;
+        HideOverlappingUI(element: VisualElement): boolean;
+        LockCursor(element: VisualElement): boolean;
+        LockPlayerInput(element: VisualElement): boolean;
+        OpenWindow(element: VisualElement, unlockCursor: boolean, lockInput: boolean, hideOverlappingUI: boolean, blurBackground: boolean): boolean;
+        Q(root: VisualElement, id: string): VisualElement;
+        RemoveFromHierarchy(root: VisualElement): void;
+        ScheduleAnimation(root: VisualElement, paramsTable: LuaTableData): Tweener;
+        SetWindowVisibilityTypes(element: VisualElement, visibilityTypes: LuaTableData): boolean;
+        ShowOverlappingUI(element: VisualElement): boolean;
+        ToUpperInvariant(text: string): string;
+        UiToViewportPoint(uiPoint: Vector2): Vector2;
+        UnblurBackground(element: VisualElement): boolean;
+        UnlockCursor(element: VisualElement): boolean;
+        UnlockPlayerInput(element: VisualElement): boolean;
+        ViewportToUiPoint(viewportPoint: Vector3): Vector2;
+    }
+    type UI = UIApi;
+    const UI: UIApi;
+    interface DotViewElement extends VisualElement {
+        count: number;
+        fillToValue: boolean;
+        value: number;
+        Reset(): void;
+    }
+    interface ElementStyleApi {
+        backgroundColor: Color;
+        backgroundImage: Texture;
+        backgroundPositionX: BackgroundPositionKeyword;
+        backgroundPositionY: BackgroundPositionKeyword;
+        backgroundSize: BackgroundSizeType;
+        borderRadius: number;
+        bottom: number;
+        color: Color;
+        display: DisplayStyle;
+        height: number;
+        heightPercent: number;
+        left: number;
+        marginBottom: number;
+        marginLeft: number;
+        marginRight: number;
+        marginTop: number;
+        maxHeight: number;
+        maxWidth: number;
+        minHeight: number;
+        minWidth: number;
+        opacity: number;
+        right: number;
+        rotate: number;
+        rotateAngle: number;
+        scale: Vector3;
+        tintColor: Color;
+        top: number;
+        translate: Vector3;
+        width: number;
+        widthPercent: number;
+    }
+    type ElementStyle = ElementStyleApi;
+    const ElementStyle: ElementStyleApi;
+    interface ImageElement extends VisualElement {
+        texture: Texture;
+    }
+    interface ScrollView extends VisualElement {
+        CanScrollByDelta(deltaY: number): boolean;
+        DisableAutoScroll(): void;
+        EnableAutoScroll(): void;
+        RefreshVerticalScrollerVisibility(): void;
+        ScrollByDelta(deltaY: number): boolean;
+        ScrollToBottom(): void;
+        ScrollToTop(): void;
+    }
+    interface TextElement extends VisualElement {
+        text: string;
+    }
+    interface TextFieldElement extends VisualElement {
+        readonly IsFocused: boolean;
+        value: string;
+        Focus(): void;
+    }
+    interface Tweener {
+        IsComplete(): boolean;
+        Stop(complete?: boolean): void;
+    }
+    interface VisualElement {
+        readonly childCount: number;
+        readonly hasChildren: boolean;
+        readonly height: number;
+        readonly name: string;
+        readonly style: ElementStyle;
+        visible: boolean;
+        readonly width: number;
+        readonly windowScale: number;
+        Add(element: VisualElement): void;
+        AddToClassList(className: string): void;
+        Clear(): void;
+        Delete(): boolean;
+        EnableInClassList(className: string, value: boolean): void;
+        EnableMouseEvents(): void;
+        GetChild(name: string): VisualElement;
+        GetChildAt(index: number): VisualElement;
+        GetPickingMode(): number;
+        OnClick(callback: () => void): void;
+        OnMouseEnter(callback: () => void): void;
+        OnMouseLeave(callback: () => void): void;
+        OnPointerDown(callback: () => void): void;
+        RemoveFromHierarchy(): void;
+        ScheduleAnimation(pars: LuaTableData): Tweener;
+        SendToBack(): void;
+        SetBorderColor(color: Color): void;
+        SetCursor(cursorName: string): boolean;
+        SetName(name: string): void;
+        SetPickingMode(mode: number): void;
+    }
+    interface WorldVisualsApi {
+        CreateLineRenderer(): LineRenderer | undefined;
+        CreateSurfaceOverlay(): SurfaceOverlay | undefined;
+        RemoveObject(toRemove: WorldObject): void;
+    }
+    type WorldVisuals = WorldVisualsApi;
+    const WorldVisuals: WorldVisualsApi;
+    interface LineRenderer extends WorldObject {
+        PositionCount: number;
+        SetColor(color: Color): void;
+        SetDistanceWidth(nearWidth: number, farWidth: number, nearDistance: number, farDistance: number): void;
+        SetOccludedVisibility(brightness: number, transparency: number): void;
+        SetPatternEnabled(enabled: boolean): void;
+        SetPatternRepeat(repeatCount: number): void;
+        SetPatternTexture(texture: Texture): void;
+        SetPosition(index: number, position: Vector3): void;
+        SetPositionCount(count: number): void;
+        SetPositions(table: LuaTableData): void;
+        SetPositions(points: LuaArray<Vector3>): void;
+        SetProgress(progress: number): void;
+        SetWidth(width: number): void;
+    }
+    interface SurfaceOverlay extends WorldObject {
+        SetColor(color: Color): void;
+        SetFillBase(fillBase: number): void;
+        SetOcclusionEnabled(on: boolean): void;
+        SetPosition(position: Vector3): void;
+        SetSize(size: Vector3): void;
+        SetVisible(on: boolean): void;
+    }
+    interface WorldObject {
+    }
+}

package/dist/generated/server.d.ts

@@ -0,0 +1,14 @@
+import "./shared.js";
+export {};
+declare global {
+    interface Aim {
+        ResetAimTarget(): void;
+        SetAimTarget(targetPosition: Vector3, agent: Agent): void;
+    }
+    interface FirearmItem {
+        GetPredictedHits(): LuaArray<LuaArray<HitscanHit>>;
+    }
+    interface SchedulerApi {
+        OnTick(callback: () => void): EventSubscription;
+    }
+}