@nativewrappers/fivem 0.0.1

package/lib/client/models/VehicleMod.js

@@ -0,0 +1,33 @@
+export class VehicleMod {
+    constructor(owner, modType) {
+        this._owner = owner;
+        this._modType = modType;
+    }
+    get ModType() {
+        return this._modType;
+    }
+    set ModType(modType) {
+        this._modType = modType;
+    }
+    get Index() {
+        return GetVehicleMod(this._owner.Handle, this.ModType);
+    }
+    set Index(value) {
+        SetVehicleMod(this._owner.Handle, this.ModType, value, this.Variation);
+    }
+    get Variation() {
+        return GetVehicleModVariation(this._owner.Handle, this.ModType);
+    }
+    set Variation(value) {
+        SetVehicleMod(this._owner.Handle, this.ModType, this.Index, value);
+    }
+    get ModCount() {
+        return GetNumVehicleMods(this._owner.Handle, this.ModType);
+    }
+    get Vehicle() {
+        return this._owner;
+    }
+    remove() {
+        RemoveVehicleMod(this._owner.Handle, this.ModType);
+    }
+}

package/lib/client/models/VehicleModCollection.d.ts

@@ -0,0 +1,61 @@
+import { Vehicle } from './Vehicle';
+import { VehicleColor, VehicleModType, VehicleNeonLight, VehiclePaintType, VehicleToggleModType, VehicleWheelType, VehicleWindowTint, LicensePlateStyle, LicensePlateType } from '../enums';
+import { VehicleMod } from './VehicleMod';
+import { Color } from '../utils';
+import { VehicleToggleMod } from './VehicleToggleMod';
+export declare class VehicleModCollection {
+    private _owner;
+    private readonly _vehicleMods;
+    private readonly _vehicleToggleMods;
+    constructor(owner: Vehicle);
+    hasVehicleMod(type: VehicleModType): boolean;
+    getMod(modType: VehicleModType): VehicleMod | undefined;
+    getToggleMod(modType: VehicleToggleModType): VehicleToggleMod | undefined;
+    getAllMods(): (VehicleMod | null | undefined)[];
+    get WheelType(): VehicleWheelType;
+    set WheelType(type: VehicleWheelType);
+    installModKit(): void;
+    get Livery(): number | undefined;
+    set Livery(value: number | undefined);
+    get LiveryCount(): number;
+    get WindowTint(): VehicleWindowTint;
+    set WindowTint(tint: VehicleWindowTint);
+    get PrimaryColor(): VehicleColor;
+    set PrimaryColor(color: VehicleColor);
+    get SecondaryColor(): VehicleColor;
+    set SecondaryColor(color: VehicleColor);
+    get RimColor(): VehicleColor;
+    set RimColor(color: VehicleColor);
+    get PearlescentColor(): VehicleColor;
+    set PearlescentColor(color: VehicleColor);
+    set TrimColor(color: VehicleColor);
+    set DashboardColor(color: VehicleColor);
+    setModColor1(paintType: VehiclePaintType, color: VehicleColor): void;
+    setModColor2(paintType: VehiclePaintType, color: VehicleColor): void;
+    get ColorCombination(): number;
+    set ColorCombination(value: number);
+    get ColorCombinationCount(): number;
+    get TireSmokeColor(): Color;
+    set TireSmokeColor(color: Color);
+    get NeonLightsColor(): Color;
+    set NeonLightsColor(color: Color);
+    isNeonLightsOn(light: VehicleNeonLight): boolean;
+    setNeonLightsOn(light: VehicleNeonLight, on: boolean): void;
+    areAllNeonLightsOn(): boolean;
+    setAllNeonLightsOn(on: boolean): void;
+    get HasAllNeonLights(): boolean;
+    hasNeonLight(light: VehicleNeonLight): boolean;
+    get CustomPrimaryColor(): Color;
+    set CustomPrimaryColor(color: Color);
+    get CustomSecondaryColor(): Color;
+    set CustomSecondaryColor(color: Color);
+    get IsPrimaryColorCustom(): boolean;
+    get IsSecondaryColorCustom(): boolean;
+    clearCustomPrimaryColor(): void;
+    clearCustomSecondaryColor(): void;
+    get LicensePlateStyle(): LicensePlateStyle;
+    set LicensePlateStyle(style: LicensePlateStyle);
+    get LicensePlateType(): LicensePlateType;
+    get LicensePlate(): string;
+    set LicensePlate(text: string);
+}

package/lib/client/models/VehicleModCollection.js

@@ -0,0 +1,227 @@
+import { VehicleModType, VehicleNeonLight, } from '../enums';
+import { VehicleMod } from './VehicleMod';
+import { Color } from '../utils';
+import { VehicleToggleMod } from './VehicleToggleMod';
+export class VehicleModCollection {
+    constructor(owner) {
+        this._vehicleMods = new Map();
+        this._vehicleToggleMods = new Map();
+        this._owner = owner;
+    }
+    hasVehicleMod(type) {
+        return GetNumVehicleMods(this._owner.Handle, type) > 0;
+    }
+    getMod(modType) {
+        if (!this._vehicleMods.has(modType)) {
+            this._vehicleMods.set(modType, new VehicleMod(this._owner, modType));
+        }
+        return this._vehicleMods.get(modType);
+    }
+    getToggleMod(modType) {
+        if (!this._vehicleToggleMods.has(modType)) {
+            this._vehicleToggleMods.set(modType, new VehicleToggleMod(this._owner, modType));
+        }
+        return this._vehicleToggleMods.get(modType);
+    }
+    getAllMods() {
+        return Object.keys(VehicleModType)
+            .filter(key => !isNaN(Number(key)))
+            .map(key => {
+            const index = Number(key);
+            if (this.hasVehicleMod(index)) {
+                return this.getMod(index);
+            }
+            return null;
+        })
+            .filter(m => m);
+    }
+    get WheelType() {
+        return GetVehicleWheelType(this._owner.Handle);
+    }
+    set WheelType(type) {
+        SetVehicleWheelType(this._owner.Handle, type);
+    }
+    installModKit() {
+        SetVehicleModKit(this._owner.Handle, 0);
+    }
+    get Livery() {
+        const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
+        if (modCount !== undefined && modCount > 0) {
+            return this.getMod(VehicleModType.Livery)?.Index;
+        }
+        return GetVehicleLivery(this._owner.Handle);
+    }
+    set Livery(value) {
+        if (value === undefined)
+            return;
+        const mod = this.getMod(VehicleModType.Livery);
+        if (mod !== undefined && mod.ModCount > 0) {
+            mod.Index = value;
+        }
+        else {
+            SetVehicleLivery(this._owner.Handle, value);
+        }
+    }
+    get LiveryCount() {
+        const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
+        if (modCount !== undefined && modCount > 0) {
+            return modCount;
+        }
+        return GetVehicleLiveryCount(this._owner.Handle);
+    }
+    get WindowTint() {
+        return GetVehicleWindowTint(this._owner.Handle);
+    }
+    set WindowTint(tint) {
+        SetVehicleWindowTint(this._owner.Handle, tint);
+    }
+    get PrimaryColor() {
+        return GetVehicleColours(this._owner.Handle)[0];
+    }
+    set PrimaryColor(color) {
+        SetVehicleColours(this._owner.Handle, color, this.SecondaryColor);
+    }
+    get SecondaryColor() {
+        return GetVehicleColours(this._owner.Handle)[1];
+    }
+    set SecondaryColor(color) {
+        SetVehicleColours(this._owner.Handle, this.PrimaryColor, color);
+    }
+    get RimColor() {
+        return GetVehicleExtraColours(this._owner.Handle)[1];
+    }
+    set RimColor(color) {
+        SetVehicleExtraColours(this._owner.Handle, this.PearlescentColor, color);
+    }
+    get PearlescentColor() {
+        return GetVehicleExtraColours(this._owner.Handle)[0];
+    }
+    set PearlescentColor(color) {
+        SetVehicleExtraColours(this._owner.Handle, color, this.RimColor);
+    }
+    set TrimColor(color) {
+        SetVehicleInteriorColour(this._owner.Handle, color);
+    }
+    set DashboardColor(color) {
+        SetVehicleDashboardColour(this._owner.Handle, color);
+    }
+    setModColor1(paintType, color) {
+        SetVehicleModColor_1(this._owner.Handle, paintType, color, 0);
+    }
+    setModColor2(paintType, color) {
+        SetVehicleModColor_2(this._owner.Handle, paintType, color);
+    }
+    get ColorCombination() {
+        return GetVehicleColourCombination(this._owner.Handle);
+    }
+    set ColorCombination(value) {
+        SetVehicleColourCombination(this._owner.Handle, value);
+    }
+    get ColorCombinationCount() {
+        return GetNumberOfVehicleColours(this._owner.Handle);
+    }
+    get TireSmokeColor() {
+        const color = GetVehicleTyreSmokeColor(this._owner.Handle);
+        return Color.fromRgb(color[0], color[1], color[2]);
+    }
+    set TireSmokeColor(color) {
+        SetVehicleTyreSmokeColor(this._owner.Handle, color.r, color.g, color.b);
+    }
+    get NeonLightsColor() {
+        const color = GetVehicleNeonLightsColour(this._owner.Handle);
+        return Color.fromRgb(color[0], color[1], color[2]);
+    }
+    set NeonLightsColor(color) {
+        SetVehicleNeonLightsColour(this._owner.Handle, color.r, color.g, color.b);
+    }
+    isNeonLightsOn(light) {
+        return IsVehicleNeonLightEnabled(this._owner.Handle, light);
+    }
+    setNeonLightsOn(light, on) {
+        SetVehicleNeonLightEnabled(this._owner.Handle, light, on);
+    }
+    areAllNeonLightsOn() {
+        if (!this.HasAllNeonLights) {
+            return false;
+        }
+        let on = true;
+        Object.keys(VehicleNeonLight)
+            .filter(key => !isNaN(Number(key)))
+            .forEach(key => {
+            if (!on) {
+                return;
+            }
+            on = this.isNeonLightsOn(Number(key));
+        });
+        return on;
+    }
+    setAllNeonLightsOn(on) {
+        Object.keys(VehicleNeonLight)
+            .filter(key => !isNaN(Number(key)))
+            .forEach(key => {
+            this.setNeonLightsOn(Number(key), on);
+        });
+    }
+    get HasAllNeonLights() {
+        return (Object.keys(VehicleNeonLight)
+            .filter(key => !isNaN(Number(key)))
+            .findIndex(light => !this.hasNeonLight(Number(light))) === -1);
+    }
+    hasNeonLight(light) {
+        if (this._owner.Bones === undefined)
+            return false;
+        switch (light) {
+            case VehicleNeonLight.Left:
+                return this._owner.Bones.hasBone('neon_l');
+            case VehicleNeonLight.Right:
+                return this._owner.Bones.hasBone('neon_r');
+            case VehicleNeonLight.Front:
+                return this._owner.Bones.hasBone('neon_f');
+            case VehicleNeonLight.Back:
+                return this._owner.Bones.hasBone('neon_b');
+            default:
+                return false;
+        }
+    }
+    get CustomPrimaryColor() {
+        const color = GetVehicleCustomPrimaryColour(this._owner.Handle);
+        return Color.fromRgb(color[0], color[1], color[2]);
+    }
+    set CustomPrimaryColor(color) {
+        SetVehicleCustomPrimaryColour(this._owner.Handle, color.r, color.g, color.b);
+    }
+    get CustomSecondaryColor() {
+        const color = GetVehicleCustomSecondaryColour(this._owner.Handle);
+        return Color.fromRgb(color[0], color[1], color[2]);
+    }
+    set CustomSecondaryColor(color) {
+        SetVehicleCustomSecondaryColour(this._owner.Handle, color.r, color.g, color.b);
+    }
+    get IsPrimaryColorCustom() {
+        return GetIsVehiclePrimaryColourCustom(this._owner.Handle);
+    }
+    get IsSecondaryColorCustom() {
+        return GetIsVehicleSecondaryColourCustom(this._owner.Handle);
+    }
+    clearCustomPrimaryColor() {
+        ClearVehicleCustomPrimaryColour(this._owner.Handle);
+    }
+    clearCustomSecondaryColor() {
+        ClearVehicleCustomSecondaryColour(this._owner.Handle);
+    }
+    get LicensePlateStyle() {
+        return GetVehicleNumberPlateTextIndex(this._owner.Handle);
+    }
+    set LicensePlateStyle(style) {
+        SetVehicleNumberPlateTextIndex(this._owner.Handle, style);
+    }
+    get LicensePlateType() {
+        return GetVehiclePlateType(this._owner.Handle);
+    }
+    get LicensePlate() {
+        return GetVehicleNumberPlateText(this._owner.Handle);
+    }
+    set LicensePlate(text) {
+        SetVehicleNumberPlateText(this._owner.Handle, text);
+    }
+}

package/lib/client/models/VehicleToggleMod.d.ts

@@ -0,0 +1,14 @@
+import { Vehicle } from './Vehicle';
+import { VehicleToggleModType } from '../enums';
+export declare class VehicleToggleMod {
+    private _owner;
+    private _modType;
+    constructor(owner: Vehicle, modType: VehicleToggleModType);
+    get ModType(): VehicleToggleModType;
+    set ModType(modType: VehicleToggleModType);
+    get IsInstalled(): boolean;
+    set IsInstalled(value: boolean);
+    get LocalizedModTypeName(): string;
+    get Vehicle(): Vehicle;
+    remove(): void;
+}

package/lib/client/models/VehicleToggleMod.js

@@ -0,0 +1,27 @@
+export class VehicleToggleMod {
+    constructor(owner, modType) {
+        this._owner = owner;
+        this._modType = modType;
+    }
+    get ModType() {
+        return this._modType;
+    }
+    set ModType(modType) {
+        this._modType = modType;
+    }
+    get IsInstalled() {
+        return IsToggleModOn(this._owner.Handle, this.ModType);
+    }
+    set IsInstalled(value) {
+        ToggleVehicleMod(this._owner.Handle, this.ModType, value);
+    }
+    get LocalizedModTypeName() {
+        return GetModSlotName(this._owner.Handle, this.ModType);
+    }
+    get Vehicle() {
+        return this._owner;
+    }
+    remove() {
+        RemoveVehicleMod(this._owner.Handle, this.ModType);
+    }
+}

package/lib/client/models/VehicleWheel.d.ts

@@ -0,0 +1,11 @@
+import { Vehicle } from './Vehicle';
+export declare class VehicleWheel {
+    private _owner;
+    private _index;
+    constructor(owner: Vehicle, index: number);
+    get Index(): number;
+    set Index(index: number);
+    get Vehicle(): Vehicle;
+    burst(): void;
+    fix(): void;
+}

package/lib/client/models/VehicleWheel.js

@@ -0,0 +1,21 @@
+export class VehicleWheel {
+    constructor(owner, index) {
+        this._owner = owner;
+        this._index = index;
+    }
+    get Index() {
+        return this._index;
+    }
+    set Index(index) {
+        this._index = index;
+    }
+    get Vehicle() {
+        return this._owner;
+    }
+    burst() {
+        SetVehicleTyreBurst(this._owner.Handle, this.Index, true, 1000);
+    }
+    fix() {
+        SetVehicleTyreFixed(this._owner.Handle, this.Index);
+    }
+}

package/lib/client/models/VehicleWheelCollection.d.ts

@@ -0,0 +1,13 @@
+import { Vehicle } from './Vehicle';
+import { VehicleWheel } from './VehicleWheel';
+import { VehicleWheelIndex } from '../enums';
+export declare class VehicleWheelCollection {
+    private _owner;
+    private readonly _vehicleWheels;
+    constructor(owner: Vehicle);
+    getWheel(index: VehicleWheelIndex): VehicleWheel | undefined;
+    getAllWheels(): (VehicleWheel | null | undefined)[];
+    burstAllWheels(): void;
+    fixAllWheels(): void;
+    hasWheel(wheel: VehicleWheelIndex): boolean;
+}

package/lib/client/models/VehicleWheelCollection.js

@@ -0,0 +1,56 @@
+import { VehicleWheel } from './VehicleWheel';
+import { VehicleWheelIndex } from '../enums';
+export class VehicleWheelCollection {
+    constructor(owner) {
+        this._vehicleWheels = new Map();
+        this._owner = owner;
+    }
+    getWheel(index) {
+        if (!this._vehicleWheels.has(index)) {
+            this._vehicleWheels.set(index, new VehicleWheel(this._owner, index));
+        }
+        return this._vehicleWheels.get(index);
+    }
+    getAllWheels() {
+        return Object.keys(VehicleWheelIndex)
+            .filter(key => !isNaN(Number(key)))
+            .map(key => {
+            const index = Number(key);
+            if (this.hasWheel(index)) {
+                return this.getWheel(index);
+            }
+            return null;
+        })
+            .filter(w => w);
+    }
+    burstAllWheels() {
+        this.getAllWheels().forEach(wheel => {
+            wheel?.burst();
+        });
+    }
+    fixAllWheels() {
+        this.getAllWheels().forEach(wheel => {
+            wheel?.fix();
+        });
+    }
+    hasWheel(wheel) {
+        if (this._owner.Bones === undefined)
+            return false;
+        switch (wheel) {
+            case VehicleWheelIndex.FrontLeftWheel:
+                return this._owner.Bones.hasBone('wheel_lf');
+            case VehicleWheelIndex.FrontRightWheel:
+                return this._owner.Bones.hasBone('wheel_rf');
+            case VehicleWheelIndex.MidLeftWheel:
+                return this._owner.Bones.hasBone('wheel_lm');
+            case VehicleWheelIndex.MidRightWheel:
+                return this._owner.Bones.hasBone('wheel_rm');
+            case VehicleWheelIndex.RearLeftWheel:
+                return this._owner.Bones.hasBone('wheel_lr');
+            case VehicleWheelIndex.RearRightWheel:
+                return this._owner.Bones.hasBone('wheel_rr');
+            default:
+                return false;
+        }
+    }
+}

package/lib/client/models/VehicleWindow.d.ts

@@ -0,0 +1,16 @@
+import { Vehicle } from './Vehicle';
+import { VehicleWindowIndex } from '../enums';
+export declare class VehicleWindow {
+    private _owner;
+    private _index;
+    constructor(owner: Vehicle, index: VehicleWindowIndex);
+    get Index(): VehicleWindowIndex;
+    set Index(index: VehicleWindowIndex);
+    get IsIntact(): boolean;
+    get Vehicle(): Vehicle;
+    repair(): void;
+    smash(): void;
+    rollUp(): void;
+    rollDown(): void;
+    remove(): void;
+}

package/lib/client/models/VehicleWindow.js

@@ -0,0 +1,33 @@
+export class VehicleWindow {
+    constructor(owner, index) {
+        this._owner = owner;
+        this._index = index;
+    }
+    get Index() {
+        return this._index;
+    }
+    set Index(index) {
+        this._index = index;
+    }
+    get IsIntact() {
+        return IsVehicleWindowIntact(this._owner.Handle, this.Index);
+    }
+    get Vehicle() {
+        return this._owner;
+    }
+    repair() {
+        FixVehicleWindow(this._owner.Handle, this.Index);
+    }
+    smash() {
+        SmashVehicleWindow(this._owner.Handle, this.Index);
+    }
+    rollUp() {
+        RollUpWindow(this._owner.Handle, this.Index);
+    }
+    rollDown() {
+        RollDownWindow(this._owner.Handle, this.Index);
+    }
+    remove() {
+        RemoveVehicleWindow(this._owner.Handle, this.Index);
+    }
+}

package/lib/client/models/VehicleWindowCollection.d.ts

@@ -0,0 +1,14 @@
+import { Vehicle } from './Vehicle';
+import { VehicleWindowIndex } from '../enums';
+import { VehicleWindow } from './VehicleWindow';
+export declare class VehicleWindowCollection {
+    private _owner;
+    private readonly _vehicleWindows;
+    constructor(owner: Vehicle);
+    getWindow(index: VehicleWindowIndex): VehicleWindow | undefined;
+    getAllWindows(): (VehicleWindow | null | undefined)[];
+    get AreAllWindowsIntact(): boolean;
+    rollDownAllWindows(): void;
+    rollUpAllWindows(): void;
+    hasWindow(window: VehicleWindowIndex): boolean;
+}

package/lib/client/models/VehicleWindowCollection.js

@@ -0,0 +1,55 @@
+import { VehicleWindowIndex } from '../enums';
+import { VehicleWindow } from './VehicleWindow';
+export class VehicleWindowCollection {
+    constructor(owner) {
+        this._vehicleWindows = new Map();
+        this._owner = owner;
+    }
+    getWindow(index) {
+        if (!this._vehicleWindows.has(index)) {
+            this._vehicleWindows.set(index, new VehicleWindow(this._owner, index));
+        }
+        return this._vehicleWindows.get(index);
+    }
+    getAllWindows() {
+        return Object.keys(VehicleWindowIndex)
+            .filter(key => !isNaN(Number(key)))
+            .map(key => {
+            const index = Number(key);
+            if (this.hasWindow(index)) {
+                return this.getWindow(index);
+            }
+            return null;
+        })
+            .filter(w => w);
+    }
+    get AreAllWindowsIntact() {
+        return AreAllVehicleWindowsIntact(this._owner.Handle);
+    }
+    rollDownAllWindows() {
+        this.getAllWindows().forEach(window => {
+            window?.rollDown();
+        });
+    }
+    rollUpAllWindows() {
+        this.getAllWindows().forEach(window => {
+            window?.rollUp();
+        });
+    }
+    hasWindow(window) {
+        if (this._owner.Bones === undefined)
+            return false;
+        switch (window) {
+            case VehicleWindowIndex.FrontLeftWindow:
+                return this._owner.Bones.hasBone('window_lf');
+            case VehicleWindowIndex.FrontRightWindow:
+                return this._owner.Bones.hasBone('window_rf');
+            case VehicleWindowIndex.BackLeftWindow:
+                return this._owner.Bones.hasBone('window_lr');
+            case VehicleWindowIndex.BackRightWindow:
+                return this._owner.Bones.hasBone('window_rr');
+            default:
+                return false;
+        }
+    }
+}

package/lib/client/models/index.d.ts

@@ -0,0 +1,18 @@
+export { Entity } from './Entity';
+export { EntityBone } from './EntityBone';
+export { EntityBoneCollection } from './EntityBoneCollection';
+export { Ped } from './Ped';
+export { PedBone } from './PedBone';
+export { PedBoneCollection } from './PedBoneCollection';
+export { Player } from './Player';
+export { Prop } from './Prop';
+export { Vehicle } from './Vehicle';
+export { VehicleDoor } from './VehicleDoor';
+export { VehicleDoorCollection } from './VehicleDoorCollection';
+export { VehicleMod } from './VehicleMod';
+export { VehicleToggleMod } from './VehicleToggleMod';
+export { VehicleModCollection } from './VehicleModCollection';
+export { VehicleWheel } from './VehicleWheel';
+export { VehicleWheelCollection } from './VehicleWheelCollection';
+export { VehicleWindow } from './VehicleWindow';
+export { VehicleWindowCollection } from './VehicleWindowCollection';

package/lib/client/models/index.js

@@ -0,0 +1,18 @@
+export { Entity } from './Entity';
+export { EntityBone } from './EntityBone';
+export { EntityBoneCollection } from './EntityBoneCollection';
+export { Ped } from './Ped';
+export { PedBone } from './PedBone';
+export { PedBoneCollection } from './PedBoneCollection';
+export { Player } from './Player';
+export { Prop } from './Prop';
+export { Vehicle } from './Vehicle';
+export { VehicleDoor } from './VehicleDoor';
+export { VehicleDoorCollection } from './VehicleDoorCollection';
+export { VehicleMod } from './VehicleMod';
+export { VehicleToggleMod } from './VehicleToggleMod';
+export { VehicleModCollection } from './VehicleModCollection';
+export { VehicleWheel } from './VehicleWheel';
+export { VehicleWheelCollection } from './VehicleWheelCollection';
+export { VehicleWindow } from './VehicleWindow';
+export { VehicleWindowCollection } from './VehicleWindowCollection';

package/lib/client/types/EntityType.d.ts

@@ -0,0 +1,2 @@
+import { Ped, Prop, Vehicle } from '../models';
+export type EntityType = Ped | Vehicle | Prop;

package/lib/client/types/EntityType.js

@@ -0,0 +1 @@
+export {};

package/lib/client/ui/Container.d.ts

@@ -0,0 +1,11 @@
+import { Color, Point, Size } from '../utils';
+import { IDrawable } from './';
+export declare class Container implements IDrawable {
+    pos: Point;
+    size: Size;
+    color: Color;
+    items: IDrawable[];
+    constructor(pos: Point, size: Size, color: Color);
+    addItem(items: IDrawable | IDrawable[]): void;
+    draw(offset?: Size, resolution?: Size): void;
+}

package/lib/client/ui/Container.js

@@ -0,0 +1,28 @@
+import { Size } from '../utils';
+import { Screen } from './';
+export class Container {
+    constructor(pos, size, color) {
+        this.items = [];
+        this.pos = pos;
+        this.size = size;
+        this.color = color;
+    }
+    addItem(items) {
+        if (!Array.isArray(items)) {
+            items = [items];
+        }
+        this.items.push(...items);
+    }
+    draw(offset, resolution) {
+        resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
+        offset = offset || new Size();
+        const w = this.size.width / resolution.width;
+        const h = this.size.height / resolution.height;
+        const x = (this.pos.X + offset.width) / resolution.width + w * 0.5;
+        const y = (this.pos.Y + offset.height) / resolution.height + h * 0.5;
+        DrawRect(x, y, w, h, this.color.r, this.color.g, this.color.b, this.color.a);
+        for (const item of this.items) {
+            item.draw(new Size(this.pos.X + offset.width, this.pos.Y + offset.height), resolution);
+        }
+    }
+}