@pma-network/redm-server 0.0.8 → 0.0.12

package/PMA.d.ts

@@ -1,6 +1,6 @@
-import type { ItemData, ItemName } from "@redm-types/Inventory";
-import type { PlayerUID } from "@redm-types/PMAPlayer";
-import { PMAPlayer } from "./class/PMAPlayer";
+import type { ItemData, ItemName } from "@pma-network/redm-types/Inventory";
+import type { PlayerUID } from "@pma-network/redm-types/PMAPlayer";
+import { PMAPlayerWrapper } from "./class/PMAPlayer";
 import type { UsableItemCall } from "./types/Inventory";
 /**
  * A static class that's used for invoking framework types
@@ -22,16 +22,16 @@ export declare class PMA {
      * isn't initialized, this won't break anything though.
      * @returns the PMAPlayer wrapper, or `null` if the player doesn't exist
      */
-    static from_source(source: number): PMAPlayer | null;
+    static from_source(source: number): PMAPlayerWrapper | null;
     /**
      * Gets the player from the specified UID
      * @returns the PMAPlayer wrapper, or `null` if there wasn't a player
      */
-    static from_uid(uid: PlayerUID): PMAPlayer | null;
+    static from_uid(uid: PlayerUID): PMAPlayerWrapper | null;
     /**
      * Gets all of the players that habe the specified job(s), and the specified {@param job_rank} if specified.
      */
-    static get_players_with_job(job_names: string | string[], job_rank?: number): PMAPlayer[];
+    static get_players_with_job(job_names: string | string[], job_rank?: number): PMAPlayerWrapper[];
     /**
      * Generic logging
      * TODO: Setup a clickhouse wrapper

package/PMA.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { PMAPlayer } from "./class/PMAPlayer";
+import { PMAPlayerWrapper } from "./class/PMAPlayer";
 class PMA {
   static {
     __name(this, "PMA");
@@ -17,7 +17,7 @@ class PMA {
    */
   static register_usable_item(item_name, fn) {
     const usable_item_wrapper = /* @__PURE__ */ __name((abstract_ply, inventory, item) => {
-      const ply = PMAPlayer.from_raw(abstract_ply);
+      const ply = PMAPlayerWrapper.from_raw(abstract_ply);
       fn(ply, inventory, item);
     }, "usable_item_wrapper");
     exports["pma"].register_usable_item(item_name, usable_item_wrapper);
@@ -30,7 +30,7 @@ class PMA {
    * @returns the PMAPlayer wrapper, or `null` if the player doesn't exist
    */
   static from_source(source) {
-    return PMAPlayer.from_source(source);
+    return PMAPlayerWrapper.from_source(source);
   }
   /**
    * Gets the player from the specified UID
@@ -38,14 +38,14 @@ class PMA {
    */
   static from_uid(uid) {
     const data = exports["pma"].from_uid(uid);
-    return data ? PMAPlayer.from_raw(data) : null;
+    return data ? PMAPlayerWrapper.from_raw(data) : null;
   }
   /**
    * Gets all of the players that habe the specified job(s), and the specified {@param job_rank} if specified.
    */
   static get_players_with_job(job_names, job_rank) {
     const players = exports["pma"].get_players_with_job(job_names, job_rank);
-    return players.map((v) => PMAPlayer.from_raw(v));
+    return players.map((v) => PMAPlayerWrapper.from_raw(v));
   }
   /**
    * Generic logging

package/class/AbstractPMAPlayer.d.ts

@@ -0,0 +1,21 @@
+import type { ItemName, OptionalItem } from "@pma-network/redm-types/Inventory";
+import { CommonAbstractPMAPlayer } from "../shared-server/types/CommonAbstractPMAPlayer";
+export declare abstract class AbstractPMAPlayer extends CommonAbstractPMAPlayer {
+    abstract get_item(item_name: ItemName): OptionalItem;
+    /**
+     * Adds the item with {@param item_name} to the players next free slot
+     * @throws This will throw an error if {@param item_name} is invalid, or if {@param quantity} is negative
+     * @returns the {@link InventoryItem} that was created, or undefined if there wasn't a free slot to put the item into.
+     */
+    abstract add_item(item_name: ItemName, quantity: number): OptionalItem;
+    /**
+     * Removes the item with {@param item_name} from the players inventory
+     * @throws This will throw an error if there wasn't enough {@param quantity} in the players inventory, you should use use has_enough_of_item to check before calling
+     */
+    abstract remove_item(item_name: ItemName, quantity: number): void;
+    /**
+     * Checks if the player has enough of {@param item_name}
+     * @returns `true` if they had enough {@param quantity}, `false` otherwise
+     */
+    abstract has_enough_of_item(item_name: ItemName, quantity: number): boolean;
+}

package/class/AbstractPMAPlayer.js

@@ -0,0 +1,11 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonAbstractPMAPlayer } from "../shared-server/types/CommonAbstractPMAPlayer";
+class AbstractPMAPlayer extends CommonAbstractPMAPlayer {
+  static {
+    __name(this, "AbstractPMAPlayer");
+  }
+}
+export {
+  AbstractPMAPlayer
+};

package/class/PMAPlayer.d.ts

@@ -1,22 +1,25 @@
-import type { ItemName, OptionalItem } from "@redm-types/Inventory";
-import { CommonPMAPlayer } from "@shared-server/class/CommonPMAPlayer";
-import type { CommonAbstractPMAPlayer } from "@shared-server/types/CommonAbstractPMAPlayer";
-export declare class PMAPlayer extends CommonPMAPlayer {
+import type { ItemName, OptionalItem } from "@pma-network/redm-types/Inventory";
+import type { NotificationVariant, PMAPartialNotification } from "@pma-network/redm-types/Notifications";
+import { CommonPMAPlayer } from "../shared-server/class/CommonPMAPlayer";
+import type { CommonAbstractPMAPlayer } from "../shared-server/types/CommonAbstractPMAPlayer";
+export declare class PMAPlayerWrapper extends CommonPMAPlayer {
     #private;
     /**
      * Creates the player from the ScRT msgpack'd class
      */
-    static from_raw(ply: CommonAbstractPMAPlayer): PMAPlayer;
+    static from_raw(ply: CommonAbstractPMAPlayer): PMAPlayerWrapper;
     /**
      * Does basic checks that the player exists before lazy initializing the player
      */
-    static from_source(source: number): PMAPlayer | null;
+    static from_source(source: number): PMAPlayerWrapper | null;
     /**
      * Creates the player from the source without doing any validity checks
      */
     static from_source_unchecked(source: number): CommonPMAPlayer;
     constructor(source: number);
     constructor(pma_player: CommonAbstractPMAPlayer);
+    send_notification(title?: string, description?: string, variant?: NotificationVariant, duration?: number): void;
+    send_notification_object(partial: PMAPartialNotification): void;
     get_item(item_name: ItemName): OptionalItem;
     add_item(item_name: ItemName, quantity: number): OptionalItem;
 }

package/class/PMAPlayer.js

@@ -1,9 +1,9 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { CommonPMAPlayer } from "@shared-server/class/CommonPMAPlayer";
-class PMAPlayer extends CommonPMAPlayer {
+import { CommonPMAPlayer } from "../shared-server/class/CommonPMAPlayer";
+class PMAPlayerWrapper extends CommonPMAPlayer {
   static {
-    __name(this, "PMAPlayer");
+    __name(this, "PMAPlayerWrapper");
   }
   // This will get lazy-initialized whenever we actually call a function that needs it,
   // this will make sure we don't pay the un-needed serialize cost if we're only using this for
@@ -13,7 +13,7 @@ class PMAPlayer extends CommonPMAPlayer {
    * Creates the player from the ScRT msgpack'd class
    */
   static from_raw(ply) {
-    return new PMAPlayer(ply);
+    return new PMAPlayerWrapper(ply);
   }
   /**
    * Does basic checks that the player exists before lazy initializing the player
@@ -22,7 +22,7 @@ class PMAPlayer extends CommonPMAPlayer {
     if (!DoesPlayerExist(source)) {
       return null;
     }
-    return new PMAPlayer(source);
+    return new PMAPlayerWrapper(source);
   }
   /**
    * Creates the player from the source without doing any validity checks
@@ -39,6 +39,17 @@ class PMAPlayer extends CommonPMAPlayer {
       super(source);
     }
   }
+  send_notification(title, description, variant = "default", duration = 5e3) {
+    const noti = {
+      body: description,
+      duration,
+      variant
+    };
+    this.emit("pma:add_notifications", noti);
+  }
+  send_notification_object(partial) {
+    this.emit("pma:add_notification", partial);
+  }
   get_item(item_name) {
     this.ensure_init();
     return this.#pma_player.get_item(item_name);
@@ -49,5 +60,5 @@ class PMAPlayer extends CommonPMAPlayer {
   }
 }
 export {
-  PMAPlayer
+  PMAPlayerWrapper
 };

package/decors/PMANetEvent.d.ts

@@ -1,5 +1,5 @@
-import { PMAPlayer } from "../class/PMAPlayer";
-type PMAServerEventType = (player: PMAPlayer, ...args: any[]) => Promise<void> | void;
+import { PMAPlayerWrapper } from "../class/PMAPlayer";
+type PMAServerEventType = (player: PMAPlayerWrapper, ...args: any[]) => Promise<void> | void;
 /**
  * Registers the Net Event call for {@link eventName} to this method
  *

package/decors/PMANetEvent.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { PMAPlayer } from "../class/PMAPlayer";
+import { PMAPlayerWrapper } from "../class/PMAPlayer";
 function OnPMANetEvent(eventName) {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
@@ -9,7 +9,7 @@ function OnPMANetEvent(eventName) {
     context.addInitializer(function() {
       const _t = this;
       onNet(eventName, async (...args) => {
-        const ply = new PMAPlayer(source);
+        const ply = new PMAPlayerWrapper(source);
         if (_t.__permissionMap) {
           const permissions = _t.__permissionMap.get(context.name);
           if (permissions) {

package/decors/RegisterUsableItems.d.ts

@@ -1,5 +1,5 @@
+import type { ItemName } from "@pma-network/redm-types/Inventory";
 import type { UsableItemCall } from "../types/Inventory";
-import type { ItemName } from "@redm-types/Inventory";
 /**
  * Registers the {@link item_name} to be usable
  *

package/index.d.ts

@@ -1,5 +1,15 @@
 export * from "./PMA";
 export * from "./types/Inventory";
+export * from "./shared-server/CommonPMA";
+export * from "./shared-server/utils/CooldownTracker";
+export * from "./shared-server/utils/FrameworkName";
+export * from "./shared-server/utils/GlobalOverrides";
+export * from "./shared-server/utils/InfractionsWrapper";
+export * from "./shared-server/types/CommonAbstractPMAPlayer";
+export * from "./shared-server/types/CommonNotifications";
+export * from "./shared-server/types/SharedTypes";
+export * from "./shared-server/class/CommonPMAPlayer";
 export * from "./decors/PMANetEvent";
 export * from "./decors/RegisterUsableItems";
+export * from "./class/AbstractPMAPlayer";
 export * from "./class/PMAPlayer";

package/index.js

@@ -1,5 +1,15 @@
 export * from "./PMA";
 export * from "./types/Inventory";
+export * from "./shared-server/CommonPMA";
+export * from "./shared-server/utils/CooldownTracker";
+export * from "./shared-server/utils/FrameworkName";
+export * from "./shared-server/utils/GlobalOverrides";
+export * from "./shared-server/utils/InfractionsWrapper";
+export * from "./shared-server/types/CommonAbstractPMAPlayer";
+export * from "./shared-server/types/CommonNotifications";
+export * from "./shared-server/types/SharedTypes";
+export * from "./shared-server/class/CommonPMAPlayer";
 export * from "./decors/PMANetEvent";
 export * from "./decors/RegisterUsableItems";
+export * from "./class/AbstractPMAPlayer";
 export * from "./class/PMAPlayer";

package/package.json

@@ -5,7 +5,7 @@
     "Dillon Skaggs <AvarianKnight>"
   ],
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.12",
   "files": [
     "./**/*.js",
     "./**/*.d.ts"

package/shared-server/CommonPMA.d.ts

@@ -0,0 +1,31 @@
+import { CommonPMAPlayer } from "./class/CommonPMAPlayer";
+import type { PlayerUID } from "./types/SharedTypes";
+/**
+ * A wraper around common functions that canbe used both in FiveM and RedM
+ */
+export declare class CommonPMA {
+    /**
+     * Gets the player from the specified source
+     * @note the PMAPlayer is lazy initialized so we don't do un-needed scrt
+     * calls, this means that we *can* possibly end up in a state where the player
+     * isn't initialized, this won't break anything though.
+     * @returns the PMAPlayer wrapper, or `null` if the player doesn't exist
+     */
+    static from_source(source: number): CommonPMAPlayer | null;
+    /**
+     * Gets the player from the specified UID
+     * @returns the PMAPlayer wrapper, or `null` if there wasn't a player
+     */
+    static from_uid(uid: PlayerUID): CommonPMAPlayer | null;
+    /**
+     * Gets all of the players that habe the specified job(s), and the specified {@param job_rank} if specified.
+     */
+    static get_players_with_job(job_names: string | string[], job_rank?: number): CommonPMAPlayer[];
+    /**
+     * Generic logging
+     * TODO: Setup a clickhouse wrapper
+     */
+    static log(log_message: string, additional_data?: {
+        [key: string]: any;
+    }): void;
+}

package/shared-server/CommonPMA.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPMAPlayer } from "./class/CommonPMAPlayer";
+import { framework_name } from "./utils/FrameworkName";
+class CommonPMA {
+  static {
+    __name(this, "CommonPMA");
+  }
+  /**
+   * Gets the player from the specified source
+   * @note the PMAPlayer is lazy initialized so we don't do un-needed scrt
+   * calls, this means that we *can* possibly end up in a state where the player
+   * isn't initialized, this won't break anything though.
+   * @returns the PMAPlayer wrapper, or `null` if the player doesn't exist
+   */
+  static from_source(source) {
+    return CommonPMAPlayer.from_source(source);
+  }
+  /**
+   * Gets the player from the specified UID
+   * @returns the PMAPlayer wrapper, or `null` if there wasn't a player
+   */
+  static from_uid(uid) {
+    const data = exports[framework_name].from_uid(uid);
+    return data ? CommonPMAPlayer.from_raw(data) : null;
+  }
+  /**
+   * Gets all of the players that habe the specified job(s), and the specified {@param job_rank} if specified.
+   */
+  static get_players_with_job(job_names, job_rank) {
+    const players = exports[framework_name].get_players_with_job(job_names, job_rank);
+    return players.map((v) => CommonPMAPlayer.from_raw(v));
+  }
+  /**
+   * Generic logging
+   * TODO: Setup a clickhouse wrapper
+   */
+  static log(log_message, additional_data) {
+    console.log(log_message, additional_data);
+  }
+}
+export {
+  CommonPMA
+};

package/shared-server/class/CommonPMAPlayer.d.ts

@@ -0,0 +1,42 @@
+import { Player } from "@nativewrappers/server";
+import type { CommonAbstractPMAPlayer } from "../types/CommonAbstractPMAPlayer";
+import type { CommonNotificationVariant, CommonPMAPartialNotification } from "../types/CommonNotifications";
+import type { CallSign, ItemName, PlayerJob, PlayerUID } from "../types/SharedTypes";
+export declare class CommonPMAPlayer extends Player implements CommonAbstractPMAPlayer {
+    #private;
+    /**
+     * Creates the player from the ScRT msgpack'd class
+     */
+    static from_raw(ply: CommonAbstractPMAPlayer): CommonPMAPlayer;
+    /**
+     * Does basic checks that the player exists before lazy initializing the player
+     */
+    static from_source(source: number): CommonPMAPlayer | null;
+    /**
+     * Creates the player from the source without doing any validity checks
+     */
+    static from_source_unchecked(source: number): CommonPMAPlayer;
+    constructor(source: number);
+    constructor(pma_player: CommonAbstractPMAPlayer);
+    ensure_init(): void;
+    is_player_valid(): boolean;
+    send_notification(title?: string, description?: string, variant?: CommonNotificationVariant, duration?: number): void;
+    send_notification_object(partial: CommonPMAPartialNotification): void;
+    get_sex(): number;
+    get_height(): number;
+    get_dob(): string;
+    get_unique_id(): PlayerUID;
+    get_call_sign(): CallSign;
+    get_character_name(): string;
+    get_log_name(): string;
+    get_item(item_name: ItemName): unknown;
+    add_item(item_name: ItemName, quantity: number): unknown;
+    remove_item(item_name: ItemName, quantity: number): void;
+    has_enough_of_item(item_name: ItemName, quantity: number): boolean;
+    get_job(): PlayerJob;
+    set_job(job_name: string, rank: number): void;
+    get_bank(): number;
+    add_to_bank(positive_amount: number): void;
+    remove_from_bank(negative_amount: number): void;
+    save(): Promise<void>;
+}

package/shared-server/class/CommonPMAPlayer.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Player } from "@nativewrappers/server";
+import { framework_name } from "../utils/FrameworkName";
+import { pma_get_player_from_id } from "../utils/GlobalOverrides";
+class CommonPMAPlayer extends Player {
+  static {
+    __name(this, "CommonPMAPlayer");
+  }
+  // This will get lazy-initialized whenever we actually call a function that needs it,
+  // this will make sure we don't pay the un-needed serialize cost if we're only using this for
+  // basic nativewrappers types
+  #pma_player = null;
+  /**
+   * Creates the player from the ScRT msgpack'd class
+   */
+  static from_raw(ply) {
+    return new CommonPMAPlayer(ply);
+  }
+  /**
+   * Does basic checks that the player exists before lazy initializing the player
+   */
+  static from_source(source) {
+    if (!DoesPlayerExist(source)) {
+      return null;
+    }
+    return new CommonPMAPlayer(source);
+  }
+  /**
+   * Creates the player from the source without doing any validity checks
+   */
+  static from_source_unchecked(source) {
+    return new CommonPMAPlayer(source);
+  }
+  constructor(source) {
+    if (typeof source !== "number") {
+      const ply = source;
+      super(ply.source);
+      this.#pma_player = ply;
+    } else {
+      super(source);
+    }
+  }
+  // Ensure we initialize the player whenever we're doing something that needs it.
+  ensure_init() {
+    if (!this.#pma_player) {
+      this.#pma_player = globalThis.pma_get_player_from_id ? (
+        // @ts-ignore: we override this in GlobalOverrides
+        globalThis.pma_get_player_from_id(this.Source)
+      ) : pma_get_player_from_id(this.Source);
+    }
+  }
+  /*
+   * This will initialize the player and check that the player exists
+   * @returns `true` if the player is loaded in the framework or `false` otherwise
+   */
+  is_player_valid() {
+    this.ensure_init();
+    return this.#pma_player !== null;
+  }
+  send_notification(title, description, variant = "default", duration = 5e3) {
+    const noti = {
+      body: description,
+      duration,
+      variant
+    };
+    this.emit("pma:add_notifications", noti);
+  }
+  send_notification_object(partial) {
+    this.emit("pma:add_notification", partial);
+  }
+  get_sex() {
+    this.ensure_init();
+    return this.#pma_player.get_sex();
+  }
+  get_height() {
+    this.ensure_init();
+    return this.#pma_player.get_height();
+  }
+  get_dob() {
+    this.ensure_init();
+    return this.#pma_player.get_dob();
+  }
+  get_unique_id() {
+    this.ensure_init();
+    return this.#pma_player.get_unique_id();
+  }
+  get_call_sign() {
+    this.ensure_init();
+    return this.#pma_player.get_call_sign();
+  }
+  get_character_name() {
+    this.ensure_init();
+    return this.#pma_player.get_character_name();
+  }
+  get_log_name() {
+    this.ensure_init();
+    return this.#pma_player.get_character_name();
+  }
+  get_item(item_name) {
+    this.ensure_init();
+    return this.#pma_player.get_item(item_name);
+  }
+  add_item(item_name, quantity) {
+    this.ensure_init();
+    return this.#pma_player.add_item(item_name, quantity);
+  }
+  remove_item(item_name, quantity) {
+    this.ensure_init();
+    return this.#pma_player.remove_item(item_name, quantity);
+  }
+  has_enough_of_item(item_name, quantity) {
+    this.ensure_init();
+    return this.#pma_player.has_enough_of_item(item_name, quantity);
+  }
+  get_job() {
+    this.ensure_init();
+    return this.#pma_player.get_job();
+  }
+  set_job(job_name, rank) {
+    this.ensure_init();
+    return this.#pma_player.set_job(job_name, rank);
+  }
+  get_bank() {
+    this.ensure_init();
+    return this.#pma_player.get_bank();
+  }
+  add_to_bank(positive_amount) {
+    this.ensure_init();
+    return this.#pma_player.add_to_bank(positive_amount);
+  }
+  remove_from_bank(negative_amount) {
+    this.ensure_init();
+    return this.#pma_player.remove_from_bank(negative_amount);
+  }
+  save() {
+    this.ensure_init();
+    return this.#pma_player.save();
+  }
+}
+export {
+  CommonPMAPlayer
+};

package/shared-server/types/CommonAbstractPMAPlayer.d.ts

@@ -0,0 +1,48 @@
+import type { CallSign, ItemName, PlayerJob, PlayerUID } from "./SharedTypes";
+export declare abstract class CommonAbstractPMAPlayer {
+    abstract get_sex(): number;
+    abstract get_height(): number;
+    abstract get_dob(): string;
+    abstract get_unique_id(): PlayerUID;
+    abstract get_call_sign(): CallSign;
+    abstract get_character_name(): string;
+    abstract get_log_name(): string;
+    abstract get_item(item_name: ItemName): unknown;
+    /**
+     * Adds the item with {@param item_name} to the players next free slot
+     *
+     * On RedM this will return `InventoryItem` on FiveM this will return `void`
+     *
+     * @throws This will throw an error if {@param item_name} is invalid, or if {@param quantity} is negative
+     * @returns the {@link InventoryItem} that was created, or undefined if there wasn't a free slot to put the item into.
+     */
+    abstract add_item(item_name: ItemName, quantity: number): unknown;
+    /**
+     * Removes the item with {@param item_name} from the players inventory
+     * @throws This will throw an error if there wasn't enough {@param quantity} in the players inventory, you should use use has_enough_of_item to check before calling
+     */
+    abstract remove_item(item_name: ItemName, quantity: number): void;
+    /**
+     * Checks if the player has enough of {@param item_name}
+     * @returns `true` if they had enough {@param quantity}, `false` otherwise
+     */
+    abstract has_enough_of_item(item_name: ItemName, quantity: number): boolean;
+    abstract get_job(): PlayerJob;
+    /**
+     * Sets the players job to the specified {@param job_name} and {@param rank}
+     * @throws This will throw if the players job is invalid
+     */
+    abstract set_job(job_name: string, rank: number): void;
+    abstract get_bank(): number;
+    /**
+     * Adds the {@param positive_amount} to the players bank.
+     * @throws if {@param positive_amount} is negative this will throw an error.
+     */
+    abstract add_to_bank(positive_amount: number): void;
+    /**
+     * Removes the {@param negative_amount} to the players bank.
+     * @throws if {@param negative_amount} is positive this will throw an error.
+     */
+    abstract remove_from_bank(negative_amount: number): void;
+    abstract save(): Promise<void>;
+}

package/shared-server/types/CommonAbstractPMAPlayer.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class CommonAbstractPMAPlayer {
+  static {
+    __name(this, "CommonAbstractPMAPlayer");
+  }
+}
+export {
+  CommonAbstractPMAPlayer
+};

package/shared-server/types/CommonNotifications.d.ts

@@ -0,0 +1,12 @@
+export type Position = "top-left" | "top-center" | "top-right" | "middle-left" | "middle" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right";
+export type CommonNotificationVariant = "default" | "error" | "success";
+export type CommonPMAPartialNotification = Omit<CommonPMANotification, "id">;
+export type CommonPMANotification = {
+    id: number;
+    title?: string;
+    body?: string;
+    variant: CommonNotificationVariant;
+    duration?: number;
+    position?: Position;
+    timeout?: number;
+};

package/shared-server/types/SharedTypes.d.ts

@@ -0,0 +1,8 @@
+export type ItemName = string;
+export type Source = number;
+export type PlayerUID = number;
+export type CallSign = string | undefined;
+export type PlayerJob = {
+    name: string;
+    rank: number;
+};

package/shared-server/utils/CooldownTracker.d.ts

@@ -0,0 +1,8 @@
+type CooldownTrackerCallback = (src: number, details: string) => void;
+export declare class CooldownTracker {
+    #private;
+    constructor(cooldown: number, cb: CooldownTrackerCallback);
+    private player_dropped;
+    try_add_cooldown(src: number, additional_details: string): boolean;
+}
+export {};

package/shared-server/utils/CooldownTracker.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Event } from "@nativewrappers/server";
+class CooldownTracker {
+  static {
+    __name(this, "CooldownTracker");
+  }
+  #cooldown_map = /* @__PURE__ */ new Map();
+  #cooldown;
+  #cb;
+  constructor(cooldown, cb) {
+    this.#cooldown = cooldown;
+    this.#cb = cb;
+  }
+  @Event("playerDropped")
+  player_dropped() {
+    this.#cooldown_map.delete(source);
+  }
+  /*
+   * @returns This returns `true` if it was successful in adding the player, or `false` the user already existed on the list
+   */
+  try_add_cooldown(src, additional_details) {
+    const gt = GetGameTimer();
+    const time = this.#cooldown_map.get(src);
+    if (!time || time < gt) {
+      this.#cooldown_map.set(src, gt + this.#cooldown);
+      return true;
+    }
+    this.#cb(src, additional_details);
+    return false;
+  }
+}
+export {
+  CooldownTracker
+};

package/shared-server/utils/FrameworkName.d.ts

@@ -0,0 +1 @@
+export declare const framework_name: string;

package/shared-server/utils/FrameworkName.js

@@ -0,0 +1,4 @@
+const framework_name = GetGameName() === "fivem" ? "pma-framework" : "pma";
+export {
+  framework_name
+};

package/shared-server/utils/GlobalOverrides.d.ts

@@ -0,0 +1,3 @@
+import type { CommonPMAPlayer } from "../class/CommonPMAPlayer";
+import type { Source } from "../types/SharedTypes";
+export declare function pma_get_player_from_id(source: Source): CommonPMAPlayer;

package/shared-server/utils/GlobalOverrides.js

@@ -0,0 +1,11 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { framework_name } from "./FrameworkName";
+function pma_get_player_from_id(source) {
+  return exports[framework_name].from_source(source);
+}
+__name(pma_get_player_from_id, "pma_get_player_from_id");
+globalThis.pma_get_player_from_id = pma_get_player_from_id;
+export {
+  pma_get_player_from_id
+};

package/types/Inventory.d.ts

@@ -1,7 +1,7 @@
-import type { PMAPlayer } from "../class/PMAPlayer";
-import type { BaseInventory, InventoryItem } from "@redm-types/Inventory";
-import type { AbstractPMAPlayer } from "@redm-types/PMAPlayer";
-export type UsableItemCall = (ply: PMAPlayer, inventory: BaseInventory, item: InventoryItem) => void;
+import type { BaseInventory, InventoryItem } from "@pma-network/redm-types/Inventory";
+import type { AbstractPMAPlayer } from "../class/AbstractPMAPlayer";
+import type { PMAPlayerWrapper } from "../class/PMAPlayer";
+export type UsableItemCall = (ply: PMAPlayerWrapper, inventory: BaseInventory, item: InventoryItem) => void;
 export type UsableItemCallShared = (ply: AbstractPMAPlayer, inventory: BaseInventory, item: InventoryItem) => void;
 export type UsableItems = {
     fn: UsableItemCallShared;