@communityox/ox_core 1.5.3

package/package/lib/server/vehicle.js

@@ -0,0 +1,66 @@
+class VehicleInterface {
+    entity;
+    netId;
+    script;
+    plate;
+    model;
+    make;
+    id;
+    vin;
+    owner;
+    group;
+    constructor(entity, netId, script, plate, model, make, id, vin, owner, group) {
+        this.entity = entity;
+        this.netId = netId;
+        this.script = script;
+        this.plate = plate;
+        this.model = model;
+        this.make = make;
+        this.id = id;
+        this.vin = vin;
+        this.owner = owner;
+        this.group = group;
+        this.entity = entity;
+        this.netId = netId;
+        this.script = script;
+        this.plate = plate;
+        this.model = model;
+        this.make = make;
+        this.id = id;
+        this.vin = vin;
+        this.owner = owner;
+        this.group = group;
+    }
+    getCoords() {
+        return this.entity ? GetEntityCoords(this.entity) : null;
+    }
+    getState() {
+        return this.entity ? Entity(this.entity).state : null;
+    }
+}
+Object.keys(exports.ox_core.GetVehicleCalls()).forEach((method) => {
+    VehicleInterface.prototype[method] = function (...args) {
+        return exports.ox_core.CallVehicle(this.vin, method, ...args);
+    };
+});
+VehicleInterface.prototype.toString = function () {
+    return JSON.stringify(this, null, 2);
+};
+function CreateVehicleInstance(vehicle) {
+    return new VehicleInterface(vehicle.entity, vehicle.netId, vehicle.script, vehicle.plate, vehicle.model, vehicle.make, vehicle.id, vehicle.vin, vehicle.owner, vehicle.group);
+}
+export function GetVehicle(vin) {
+    return typeof vin === 'string' ? GetVehicleFromVin(vin) : CreateVehicleInstance(exports.ox_core.GetVehicle(vin));
+}
+export function GetVehicleFromNetId(netId) {
+    return CreateVehicleInstance(exports.ox_core.GetVehicleFromNetId(netId));
+}
+export function GetVehicleFromVin(vin) {
+    return CreateVehicleInstance(exports.ox_core.GetVehicleFromVin(vin));
+}
+export async function CreateVehicle(data, coords, heading) {
+    return CreateVehicleInstance(await exports.ox_core.CreateVehicle(data, coords, heading));
+}
+export async function SpawnVehicle(dbId, coords, heading) {
+    return CreateVehicleInstance(await exports.ox_core.SpawnVehicle(dbId, coords, heading));
+}

package/package/server/accounts/class.d.ts

@@ -0,0 +1,65 @@
+import { ClassInterface } from 'classInterface';
+import type { Dict, OxAccountMetadata, OxAccountRole, OxAccountPermissions, OxCreateInvoice } from '../../types';
+interface UpdateAccountBalance {
+    amount: number;
+    message?: string;
+}
+interface RemoveAccountBalance extends UpdateAccountBalance {
+    overdraw?: boolean;
+}
+interface TransferAccountBalance {
+    toId: number;
+    amount: number;
+    overdraw?: boolean;
+    message?: string;
+    note?: string;
+    actorId?: number;
+}
+export declare class OxAccount extends ClassInterface {
+    accountId: number;
+    protected static members: Dict<OxAccount>;
+    static get(accountId: number): Promise<OxAccount>;
+    static getAll(): Dict<OxAccount>;
+    constructor(accountId: number);
+    get<T extends keyof OxAccountMetadata>(key: T): Promise<OxAccountMetadata[T]>;
+    get<T extends keyof OxAccountMetadata>(keys: T[]): Promise<Pick<OxAccountMetadata, T>>;
+    addBalance({ amount, message }: UpdateAccountBalance): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    removeBalance({ amount, overdraw, message }: RemoveAccountBalance): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    transferBalance({ toId, amount, overdraw, message, note, actorId }: TransferAccountBalance): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    depositMoney(playerId: number, amount: number, message?: string, note?: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    withdrawMoney(playerId: number, amount: number, message?: string, note?: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    deleteAccount(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    getCharacterRole(id: number | string): Promise<OxAccountRole | null>;
+    setCharacterRole(id: number | string, role?: OxAccountRole): Promise<0 | {
+        success: boolean;
+        message?: string;
+    } | null>;
+    playerHasPermission(playerId: number, permission: keyof OxAccountPermissions): Promise<boolean>;
+    setShared(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    createInvoice(data: Omit<OxCreateInvoice, 'fromAccount'>): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+}
+export {};

package/package/server/accounts/db.d.ts

@@ -0,0 +1,47 @@
+import type { OxAccountMetadata, OxAccountRole, OxCreateInvoice } from '../../types';
+export declare function UpdateBalance(accountId: number, amount: number, action: 'add' | 'remove', overdraw: boolean, message?: string, note?: string, actorId?: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function PerformTransaction(fromId: number, toId: number, amount: number, overdraw: boolean, message?: string, note?: string, actorId?: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function SelectAccounts(column: 'owner' | 'group' | 'id', id: number | string): Promise<OxAccountMetadata[]>;
+export declare function SelectDefaultAccountId(column: 'owner' | 'group' | 'id', id: number | string): Promise<number | null>;
+export declare function SelectAccount(id: number): Promise<OxAccountMetadata | null>;
+export declare function IsAccountIdAvailable(id: number): Promise<boolean>;
+export declare function CreateNewAccount(owner: string | number, label: string, isDefault?: boolean): Promise<number>;
+export declare function DeleteAccount(accountId: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function SelectAccountRole(accountId: number, charId: number): Promise<OxAccountRole | null>;
+export declare function DepositMoney(playerId: number, accountId: number, amount: number, message?: string, note?: string): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function WithdrawMoney(playerId: number, accountId: number, amount: number, message?: string, note?: string): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function UpdateAccountAccess(accountId: number, id: number, role?: string): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function UpdateInvoice(invoiceId: number, charId: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function CreateInvoice({ actorId, fromAccount, toAccount, amount, message, dueDate, }: OxCreateInvoice): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function DeleteInvoice(invoiceId: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function SetAccountType(accountId: number, type: string): Promise<{
+    success: boolean;
+    message?: string;
+}>;

package/package/server/accounts/index.d.ts

@@ -0,0 +1,12 @@
+import { OxAccount } from './class';
+export declare function GetCharacterAccount(id: number | string): Promise<OxAccount | null>;
+export declare function GetGroupAccount(groupName: string): Promise<OxAccount | null>;
+export declare function CreateAccount(owner: number | string, label: string): Promise<OxAccount>;
+export declare function PayAccountInvoice(invoiceId: number, charId: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;
+export declare function DeleteAccountInvoice(invoiceId: number): Promise<{
+    success: boolean;
+    message?: string;
+}>;

package/package/server/accounts/roles.d.ts

@@ -0,0 +1,4 @@
+import type { OxAccountPermissions, OxAccountRole } from '../../types';
+import type { OxPlayer } from 'player/class';
+export declare function CheckRolePermission(roleName: OxAccountRole | null, permission: keyof OxAccountPermissions): boolean | undefined;
+export declare function CanPerformAction(player: OxPlayer, accountId: number, role: OxAccountRole | null, action: keyof OxAccountPermissions): Promise<boolean>;

package/package/server/bridge/index.d.ts

@@ -0,0 +1,2 @@
+import './npwd';
+import './ox_inventory';

package/package/server/bridge/npwd.d.ts

@@ -0,0 +1 @@
+export declare function GeneratePhoneNumber(): any;

package/package/server/bridge/ox_inventory.d.ts

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

package/package/server/classInterface.d.ts

@@ -0,0 +1,13 @@
+import type { Dict } from '../types';
+export declare class ClassInterface {
+    protected static members: Dict<any>;
+    protected static keys?: Dict<Dict<any>>;
+    protected static callableMethods: Dict<true>;
+    static isCallValid(method: string, id: string | number, member: any): true | void;
+    static init(): typeof ClassInterface;
+    call(method: string, ...args: any): any;
+    static get(id: string | number): any;
+    static getAll(): Dict<any>;
+    static add(id: string | number, member: any): boolean;
+    static remove(id: string | number): boolean;
+}

package/package/server/commands.d.ts

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

package/package/server/config.d.ts

@@ -0,0 +1,2 @@
+export * from '../common/config';
+export declare const CREATE_DEFAULT_ACCOUNT: boolean;

package/package/server/db/config.d.ts

@@ -0,0 +1,2 @@
+import type { PoolConfig } from 'mariadb';
+export declare function GetConfig(): PoolConfig;

package/package/server/db/index.d.ts

@@ -0,0 +1,39 @@
+import type { Dict } from '../../types';
+import type { PoolConnection, QueryOptions } from 'mariadb';
+export interface MySqlRow<T = string | number | boolean | Dict<any> | undefined> {
+    [column: string]: T;
+}
+export interface OkPacket {
+    affectedRows: number;
+    insertId: number;
+    warningStatus: any;
+}
+export declare class Connection {
+    connection: PoolConnection;
+    transaction?: boolean;
+    constructor(connection: PoolConnection);
+    execute<T = MySqlRow[] & OkPacket>(query: string | QueryOptions, values?: any[]): Promise<T>;
+    query<T = MySqlRow[] & OkPacket>(query: string | QueryOptions, values?: any[]): Promise<T>;
+    scalar<T>(query: string | QueryOptions, values?: any[]): Promise<T | null>;
+    row<T>(query: string | QueryOptions, values?: any[]): Promise<T | null>;
+    insert(query: string | QueryOptions, values?: any[]): Promise<number>;
+    update(query: string | QueryOptions, values?: any[]): Promise<number>;
+    batch(query: string | QueryOptions, values?: any[]): Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]>;
+    beginTransaction(): Promise<void>;
+    rollback(): Promise<void>;
+    commit(): Promise<void>;
+    [Symbol.dispose](): void;
+}
+export declare function GetConnection(): Promise<Connection>;
+export declare const db: {
+    query<T>(query: string | QueryOptions, values?: any[]): Promise<T extends OkPacket ? OkPacket : T[]>;
+    execute<T>(query: string | QueryOptions, values?: any[]): Promise<T extends OkPacket ? OkPacket : T[]>;
+    column<T>(query: string | QueryOptions, values?: any[]): Promise<T | null>;
+    exists<T>(query: string | QueryOptions, values?: any[]): Promise<boolean>;
+    row<T>(query: string | QueryOptions, values?: any[]): Promise<T | null>;
+    insert(query: string | QueryOptions, values?: any[]): Promise<number>;
+    update(query: string | QueryOptions, values?: any[]): Promise<number>;
+    batch(query: string | QueryOptions, values?: any[]): Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]>;
+    scalar<T>(resp: T[] | null): T | null;
+    single<T>(resp: T[] | null): T | null;
+};

package/package/server/db/pool.d.ts

@@ -0,0 +1,2 @@
+import type { Pool } from 'mariadb';
+export declare let pool: Pool;

package/package/server/db/schema.d.ts

@@ -0,0 +1,2 @@
+import { Pool } from 'mariadb';
+export default function (pool: Pool): Promise<void>;

package/package/server/groups/db.d.ts

@@ -0,0 +1,13 @@
+import type { DbGroup } from '../../types';
+export declare function SelectGroups(): Promise<DbGroup[]>;
+export declare function InsertGroup({ name, label, type, colour, hasAccount, grades, accountRoles }: DbGroup): Promise<boolean>;
+export declare function RemoveGroup(groupName: string): Promise<number>;
+export declare function AddCharacterGroup(charId: number, name: string, grade: number): Promise<boolean>;
+export declare function UpdateCharacterGroup(charId: number, name: string, grade: number): Promise<boolean>;
+export declare function RemoveCharacterGroup(charId: number, name: string): Promise<boolean>;
+export declare function GetCharacterGroups(charId: number): Promise<{
+    name: string;
+    grade: number;
+    isActive: boolean;
+}[]>;
+export declare function SetActiveGroup(charId: number, groupName?: string): Promise<void>;

package/package/server/groups/index.d.ts

@@ -0,0 +1,7 @@
+import type { OxGroup, CreateGroupProperties } from '../../types';
+export declare function GetGroup(name: string): OxGroup;
+export declare function GetGroupsByType(type: string): string[];
+export declare function SetGroupPermission(groupName: string, grade: number, permission: string, value: 'allow' | 'deny'): void;
+export declare function RemoveGroupPermission(groupName: string, grade: number, permission: string): void;
+export declare function CreateGroup(data: CreateGroupProperties): Promise<void>;
+export declare function DeleteGroup(groupName: string): Promise<void>;

package/package/server/index.d.ts

@@ -0,0 +1,6 @@
+export * from '../common';
+import './bridge';
+import 'player';
+import 'utils';
+import 'accounts';
+import 'vehicle';

package/package/server/player/class.d.ts

@@ -0,0 +1,54 @@
+import { ClassInterface } from 'classInterface';
+import type { Character, Dict, NewCharacter, PlayerMetadata, CharacterLicense, BanDetails } from '../../types';
+export declare class OxPlayer extends ClassInterface {
+    #private;
+    source: number | string;
+    userId: number;
+    charId?: number;
+    stateId?: string;
+    username: string;
+    identifier: string;
+    ped: number;
+    protected static members: Dict<OxPlayer>;
+    protected static keys: Dict<Dict<OxPlayer>>;
+    static get(id: string | number): OxPlayer;
+    static getFromUserId(id: number): OxPlayer;
+    static getFromCharId(id: number): OxPlayer;
+    static formatBanReason(ban: BanDetails): string;
+    private filter;
+    static getFromFilter(filter: Dict<any>): OxPlayer | undefined;
+    static getAll(filter?: Dict<any>, asArray?: false): Dict<OxPlayer>;
+    static getAll(filter?: Dict<any>, asArray?: true): OxPlayer[];
+    static saveAll(kickWithReason?: string): void;
+    constructor(source: number);
+    emit(eventName: string, ...args: any[]): void;
+    set<K extends string>(key: K | keyof PlayerMetadata, value: K extends keyof PlayerMetadata ? PlayerMetadata[K] : any, replicated?: boolean): void;
+    get<K extends string>(key: K | keyof PlayerMetadata): K extends keyof PlayerMetadata ? PlayerMetadata[K] : any;
+    payInvoice(invoiceId: number): Promise<{
+        success: boolean;
+        message?: string;
+    } | undefined>;
+    setActiveGroup(groupName?: string, temp?: boolean): boolean;
+    setGroup(groupName: string, grade?: number): Promise<boolean | void>;
+    getGroup(filter: string): number;
+    getGroup(filter: string[] | Record<string, number>): [string, number] | [];
+    getGroupByType(type: string): [] | [string, number];
+    getGroups(): Dict<number>;
+    hasPermission(permission: string): boolean;
+    setStatus(statusName: string, value?: number): true | undefined;
+    getStatus(statusName: string): number;
+    getStatuses(): Dict<number>;
+    addStatus(statusName: string, value: number): true | undefined;
+    removeStatus(statusName: string, value: number): true | undefined;
+    getLicense(licenseName: string): CharacterLicense;
+    getLicenses(): Dict<CharacterLicense>;
+    addLicense(licenseName: string): Promise<boolean>;
+    removeLicense(licenseName: string): Promise<boolean>;
+    updateLicense(licenseName: string, key: string, value: any): Promise<boolean>;
+    save(): Promise<number> | Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]> | undefined;
+    setAsJoined(): Promise<void>;
+    logout(save?: boolean, dropped?: boolean): Promise<void>;
+    createCharacter(data: NewCharacter): Promise<number | undefined>;
+    setActiveCharacter(data: number | NewCharacter): Promise<Character | undefined>;
+    deleteCharacter(charId: number): Promise<true | undefined>;
+}

package/package/server/player/commands.d.ts

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

package/package/server/player/db.d.ts

@@ -0,0 +1,32 @@
+import type { Character, Dict, OxStatus, CharacterLicense, OxLicense, BanDetails } from '../../types';
+export declare function GetUserIdFromIdentifier(identifier: string, offset?: number): Promise<number | null>;
+export declare function CreateUser(username: string, { license2, steam, fivem, discord }: Dict<string>): Promise<number>;
+export declare function IsStateIdAvailable(stateId: string): Promise<boolean>;
+export declare function CreateCharacter(userId: number, stateId: string, firstName: string, lastName: string, gender: string, date: number, phoneNumber?: number): Promise<number>;
+export declare function GetCharacters(userId: number): Promise<Character[]>;
+export declare function SaveCharacterData(values: any[] | any[][], batch?: boolean): Promise<number> | Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]>;
+export declare function DeleteCharacter(charId: number): Promise<boolean>;
+export declare function GetCharacterMetadata(charId: number): Promise<{
+    isDead: number;
+    gender: string;
+    dateOfBirth: string;
+    phoneNumber: string;
+    health: number;
+    armour: number;
+    statuses: Dict<number>;
+} | null>;
+export declare function GetStatuses(): Promise<OxStatus[]>;
+export declare function GetLicenses(): Promise<Dict<OxLicense>[]>;
+export declare function GetLicense(name: string): Promise<OxLicense | null>;
+export declare function GetCharacterLicenses(charId: number): Promise<{
+    name: string;
+    data: CharacterLicense;
+}[]>;
+export declare function AddCharacterLicense(charId: number, name: string, data: CharacterLicense): Promise<number>;
+export declare function RemoveCharacterLicense(charId: number, name: string): Promise<number>;
+export declare function UpdateCharacterLicense(charId: number, name: string, key: string, value: any): Promise<number>;
+export declare function GetCharIdFromStateId(stateId: string): Promise<number | null>;
+export declare function UpdateUserTokens(userId: number, tokens: string[]): Promise<void>;
+export declare function IsUserBanned(userId: number): Promise<BanDetails | undefined>;
+export declare function BanUser(userId: number, reason?: string, hours?: number): Promise<boolean>;
+export declare function UnbanUser(userId: number): Promise<number>;

package/package/server/player/events.d.ts

@@ -0,0 +1,4 @@
+import { OxPlayer } from './class';
+import './license';
+export declare function OnPlayerLoaded(resource: string, cb: (player: OxPlayer) => void): void;
+export declare function OnPlayerLogout(cb: (player: OxPlayer) => void): void;

package/package/server/player/index.d.ts

@@ -0,0 +1,3 @@
+import './loading';
+import './events';
+import './commands';

package/package/server/player/license.d.ts

@@ -0,0 +1,2 @@
+import type { Dict, OxLicense } from '../../types';
+export declare const Licenses: Dict<OxLicense>;

package/package/server/player/loading.d.ts

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

package/package/server/player/status.d.ts

@@ -0,0 +1,2 @@
+import type { Dict, OxStatus } from '../../types';
+export declare const Statuses: Dict<OxStatus>;

package/package/server/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Dict } from '../types';
+export declare function GetPlayerLicense(playerId: number | string): string;
+export declare function GetIdentifiers(playerId: number | string): Dict<string>;

package/package/server/vehicle/class.d.ts

@@ -0,0 +1,51 @@
+import { ClassInterface } from 'classInterface';
+import { type VehicleProperties } from '@communityox/ox_lib';
+import type { Dict, VehicleData } from '../../types';
+import { Vector3 } from '@nativewrappers/server';
+export type Vec3 = number[] | {
+    x: number;
+    y: number;
+    z: number;
+} | {
+    buffer: any;
+};
+export declare class OxVehicle extends ClassInterface {
+    #private;
+    script: string;
+    plate: string;
+    model: string;
+    make: string;
+    id?: number;
+    vin: string;
+    owner?: number;
+    group?: string;
+    entity?: number;
+    netId?: number;
+    protected static members: Dict<OxVehicle>;
+    protected static keys: Dict<Dict<OxVehicle>>;
+    static spawn(model: string, coords: Vector3, heading?: number): number;
+    static get(vin: string): OxVehicle | Promise<OxVehicle | undefined>;
+    static getFromVehicleId(vehicleId: number): OxVehicle;
+    static getFromNetId(id: number): OxVehicle;
+    static getFromEntity(entityId: number): OxVehicle;
+    static getAll(): Dict<OxVehicle>;
+    static generateVin({ make, name }: VehicleData, isOwned?: boolean): Promise<string>;
+    static generatePlate(): Promise<string>;
+    static saveAll(resource?: string): void;
+    constructor(vin: string, script: string, plate: string, model: string, make: string, stored: string | null, metadata: Dict<any>, properties: VehicleProperties, id?: number, owner?: number, group?: string);
+    set(key: string, value: any): void;
+    get(key: string): any;
+    getState(): StateBagInterface | null;
+    getStored(): string | null;
+    getProperties(): VehicleProperties;
+    save(): Promise<number> | Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]> | undefined;
+    despawn(save?: boolean): void;
+    delete(): void;
+    remove(): void;
+    setStored(value: string | null, despawn?: boolean): void;
+    setOwner(charId?: number): void;
+    setGroup(group?: string): void;
+    setPlate(plate: string): void;
+    setProperties(properties: VehicleProperties, apply?: boolean): void;
+    respawn(coords?: Vec3, rotation?: Vector3 | number): number | null;
+}

package/package/server/vehicle/commands.d.ts

@@ -0,0 +1 @@
+export declare function DeleteCurrentVehicle(ped: number): void;

package/package/server/vehicle/db.d.ts

@@ -0,0 +1,20 @@
+import type { VehicleProperties } from '@communityox/ox_lib';
+export type VehicleRow = {
+    id: number;
+    owner?: number;
+    group?: string;
+    plate: string;
+    vin: string;
+    model: string;
+    data: {
+        properties: VehicleProperties;
+        [key: string]: any;
+    };
+};
+export declare function IsPlateAvailable(plate: string): Promise<boolean>;
+export declare function IsVinAvailable(plate: string): Promise<boolean>;
+export declare function GetStoredVehicleFromId(id: number | string, column?: string): Promise<VehicleRow | null>;
+export declare function SetVehicleColumn(id: number | void, column: string, value: any): Promise<boolean | undefined>;
+export declare function SaveVehicleData(values: any, batch?: boolean): Promise<number> | Promise<import("mariadb").UpsertResult | import("mariadb").UpsertResult[]>;
+export declare function CreateNewVehicle(plate: string, vin: string, owner: number | null, group: string | null, model: string, vehicleClass: number, data: object, stored: string | null): Promise<number>;
+export declare function DeleteVehicle(id: number): Promise<boolean>;

package/package/server/vehicle/events.d.ts

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

package/package/server/vehicle/index.d.ts

@@ -0,0 +1,15 @@
+import { OxVehicle, Vec3 } from './class';
+import { type VehicleRow } from './db';
+import './class';
+import './commands';
+import './events';
+import type { VehicleProperties } from '@communityox/ox_lib/server';
+export interface CreateVehicleData {
+    model: string;
+    owner?: number;
+    group?: string;
+    stored?: string;
+    properties?: VehicleProperties;
+}
+export declare function CreateVehicle(data: string | (CreateVehicleData & Partial<VehicleRow>), coords?: Vec3, heading?: number, invokingScript?: string): Promise<OxVehicle>;
+export declare function SpawnVehicle(id: number | string, coords?: Vec3, heading?: number): Promise<OxVehicle | undefined>;

package/package/server/vehicle/parser.d.ts

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