@nativewrappers/redm 0.0.122 → 0.0.123

package/Task.js

@@ -7,6 +7,7 @@ import { DrivingStyle } from "./enums/Driving";
 import { FiringPatterns } from "./enums/FiringPatterns";
 import { VehicleSeat } from "./enums/VehicleSeat";
 import { LoadAnimDict } from "./utils/Animations";
+import { CommonTasks } from "./common-game/CommonTasks";
 class Tasks {
   static {
     __name(this, "Tasks");
@@ -16,7 +17,7 @@ class Tasks {
   // you betterk now what you're doing.
   constructor(ped) {
     const actualPed = ped ?? { handle: null };
-    this.ped = actualPed;
+    this.ped = ped;
   }
   achieveHeading(heading, timeout = 0) {
     TaskAchieveHeading(this.ped.Handle, heading, timeout);

package/common/decors/ConVar.d.ts

@@ -0,0 +1,14 @@
+export declare enum ConVarType {
+    String = 0,
+    Integer = 1,
+    Float = 2,
+    Boolean = 3
+}
+type DeserializeFn<T> = (data: T) => unknown;
+/**
+ * Gets the specified `ConVar`s value, this will bind to the param.
+ * @param name the convar name
+ * @param is_floating_point if the convar is floating point, this should be explicitly set to true if your convar will be a float
+ */
+export declare function ConVar<T>(name: string, is_floating_point?: boolean, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
+export {};

package/common/decors/ConVar.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var ConVarType = /* @__PURE__ */ ((ConVarType2) => {
+  ConVarType2[ConVarType2["String"] = 0] = "String";
+  ConVarType2[ConVarType2["Integer"] = 1] = "Integer";
+  ConVarType2[ConVarType2["Float"] = 2] = "Float";
+  ConVarType2[ConVarType2["Boolean"] = 3] = "Boolean";
+  return ConVarType2;
+})(ConVarType || {});
+const get_convar_fn = /* @__PURE__ */ __name((con_var_type) => {
+  switch (con_var_type) {
+    case 0 /* String */:
+      return GetConvar;
+    case 1 /* Integer */:
+      return GetConvarInt;
+    case 2 /* Float */:
+      return GetConvarFloat;
+    case 3 /* Boolean */:
+      return GetConvarBool;
+    // needed so typescript wont complain about "unreachable code" for the error below
+    default:
+  }
+  throw new Error("Got invalid ConVarType");
+}, "get_convar_fn");
+function ConVar(name, is_floating_point, deserialize) {
+  return /* @__PURE__ */ __name(function actualDecorator(_initialValue, context, ..._args) {
+    if (context.private) {
+      throw new Error("ConVar does not work on private types, please mark the field as public");
+    }
+    context.addInitializer(function() {
+      const t = this;
+      const default_value = Reflect.get(t, context.name);
+      const default_type = typeof default_value;
+      let con_var_type = null;
+      if (default_type === "number") {
+        if (is_floating_point || !Number.isInteger(default_value)) {
+          con_var_type = 2 /* Float */;
+        } else {
+          con_var_type = 1 /* Integer */;
+        }
+      } else if (default_type === "boolean") {
+        con_var_type = 3 /* Boolean */;
+      } else if (default_type === "string") {
+        con_var_type = 0 /* String */;
+      }
+      if (!deserialize && con_var_type === null) {
+        throw new Error(
+          `Failed to determine what to use to deserialize '${name}' was for var had type '${default_type}' which can't be deserialized without providing your own deserialize function.`
+        );
+      }
+      if (con_var_type === null) {
+        con_var_type = 0 /* String */;
+      }
+      const con_var_fn = get_convar_fn(con_var_type);
+      const get_convar_value = /* @__PURE__ */ __name(() => {
+        const data = con_var_fn(name, default_value);
+        return deserialize ? deserialize(data) : data;
+      }, "get_convar_value");
+      Reflect.set(t, context.name, get_convar_value());
+      AddConvarChangeListener(name, () => {
+        Reflect.set(t, context.name, get_convar_value());
+      });
+    });
+  }, "actualDecorator");
+}
+__name(ConVar, "ConVar");
+export {
+  ConVar,
+  ConVarType
+};

package/common/decors/Events.d.ts

@@ -1,24 +1,35 @@
-export declare enum ConVarType {
-    String = 0,
-    Integer = 1,
-    Float = 2,
-    Boolean = 3
-}
 /**
  * Disables pretty printing in error messages
  */
 export declare const DisablePrettyPrint: () => boolean;
-export declare function Exports(exportName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare enum Binding {
+    /**
+     * No one can call this
+     */
+    None = 0,
+    /**
+     * Server only accepts server calls, client only client calls
+     */
+    Local = 1,
+    /**
+     * Server only accepts client calls, client only server calls
+     */
+    Remote = 2,
+    /**
+     * Accept all incoming calls
+     * Server only accepts client calls, client only server calls
+     */
+    All = 3
+}
 /**
  * Registers the Event call for {@link eventName} to this method.
  *
  * This has internal pretty-printing to make errors easier to track, if
  * you want to disable this you will need to call {@link DisablePrettyPrint}, or if you're
  * using esbuild you can add `REMOVE_EVENT_LOG` to your drop label {@link https://esbuild.github.io/api/#drop-labels}
- *
  * @param eventName the event to bind to
  */
-export declare function Event(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function CfxEvent(eventName: string, binding?: Binding): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
 /**
  * Registers the Event call for {@link eventName} to this method.
  *
@@ -26,10 +37,9 @@ export declare function Event(eventName: string): (originalMethod: any, context:
  * you want to disable this you will need to call {@link DisablePrettyPrint}, or if you're
  * using esbuild you can add `REMOVE_EVENT_LOG` to your drop label {@link https://esbuild.github.io/api/#drop-labels}
  *
- * This is the same thing as just using `Event` but this disambiguates the call from DOM
  * @param eventName the event to bind to
  */
-export declare const CfxEvent: typeof Event;
+export declare function Event(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
 /**
  * Registers the Net Event call for {@link eventName} to this method
  *
@@ -42,24 +52,15 @@ export declare const CfxEvent: typeof Event;
  * @param remoteOnly if the event should only accept remote calls, if set to true it will ignore any local call via `emit`, defaults to true
  */
 export declare function NetEvent(eventName: string, remoteOnly?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export type NuiCallback = (data: string) => void;
 /**
  * Registers the NUI Event call for {eventName} to this method, the function signature
- * should be (data: unknown, cb: (data?: any) => void) => void
- * You shoud always execute `cb` with 'ok' if you don't want to send data back to
- * the UI, otherwise you'll cause a network error for the `fetch` request
+ * will always be (data: unknown, cb: (data?: any) => void) => void
+ *
+ * There's two valid ways to return data into a callback, returning in the method
+ * you're currently using will automatically call the callback, or you can manually call the callback yourself
+ *
  * @param eventName the event this will listen for
+ * @param dontErrorWhenCbIsntInvoked this will just block the event fro merroring when the callback is never invoked.
  */
-export declare function NuiEvent(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
-type DeserializeFn<T> = (data: T) => unknown;
-/**
- * Gets the specified `ConVar`s value, this will bind to the param.
- * @param name the convar name
- * @param is_floating_point if the convar is floating point, this should be explicitly set to true if your convar will be a float
- */
-export declare function ConVar<T>(name: string, is_floating_point?: boolean, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
-/**
- * Gets called per server/client tick, this is asyncronous though, if you await
- * in it, it will not be called until whatever was being awaited resolves.
- */
-export declare function SetTick(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
-export {};
+export declare function NuiEvent(eventName: string, dontErrorWhenCbIsntInvoked?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common/decors/Events.js

@@ -1,61 +1,59 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { GlobalData } from "../GlobalData";
-var ConVarType = /* @__PURE__ */ ((ConVarType2) => {
-  ConVarType2[ConVarType2["String"] = 0] = "String";
-  ConVarType2[ConVarType2["Integer"] = 1] = "Integer";
-  ConVarType2[ConVarType2["Float"] = 2] = "Float";
-  ConVarType2[ConVarType2["Boolean"] = 3] = "Boolean";
-  return ConVarType2;
-})(ConVarType || {});
 const DisablePrettyPrint = /* @__PURE__ */ __name(() => GlobalData.EnablePrettyPrint = false, "DisablePrettyPrint");
 const AsyncFunction = (async () => {
 }).constructor;
-function Exports(exportName) {
+var Binding = /* @__PURE__ */ ((Binding2) => {
+  Binding2[Binding2["None"] = 0] = "None";
+  Binding2[Binding2["Local"] = 1] = "Local";
+  Binding2[Binding2["Remote"] = 2] = "Remote";
+  Binding2[Binding2["All"] = 3] = "All";
+  return Binding2;
+})(Binding || {});
+function CfxEvent(eventName, binding = 1 /* Local */) {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
-      throw new Error("Exports does not work on private methods, please mark the method as public");
+      throw new Error("Event does not work on private methods, please mark the method as public");
     }
     context.addInitializer(function() {
-      let exportCb;
-      if (originalMethod instanceof AsyncFunction) {
-        exportCb = /* @__PURE__ */ __name(async (...args) => {
-          try {
-            return await originalMethod.call(this, ...args);
-          } catch (err) {
-            REMOVE_EVENT_LOG: {
-              if (!GlobalData.EnablePrettyPrint) return;
-              console.error("------- EXPORT ERROR --------");
-              console.error(`Call to ${exportName} errored`);
-              console.error(`Data: ${JSON.stringify(args)}`);
-              console.error(`Error: ${err}`);
-              console.error("------- END EXPORT ERROR --------");
+      const fn = (binding & 2 /* Remote */) !== 0 ? onNet : on;
+      const _t = this;
+      fn(eventName, async (...args) => {
+        const src = source;
+        if (_t.__permissionMap && binding & 2 /* Remote */) {
+          const permissions = _t.__permissionMap.get(context.name);
+          if (permissions) {
+            let hasPermission = false;
+            for (const perm of permissions) {
+              if (IsPlayerAceAllowed(src, perm)) {
+                hasPermission = true;
+                break;
+              }
             }
-            throw err;
-          }
-        }, "exportCb");
-      } else {
-        exportCb = /* @__PURE__ */ __name((...args) => {
-          try {
-            return originalMethod.call(this, ...args);
-          } catch (err) {
-            REMOVE_EVENT_LOG: {
-              if (!GlobalData.EnablePrettyPrint) return;
-              console.error("------- EXPORT ERROR --------");
-              console.error(`Call to ${exportName} errored`);
-              console.error(`Data: ${JSON.stringify(args)}`);
-              console.error(`Error: ${err}`);
-              console.error("------- END EXPORT ERROR --------");
+            if (!hasPermission) {
+              emit("@nativewrappers:no_permission", { eventName, method: context.name });
+              return;
             }
-            throw err;
           }
-        }, "exportCb");
-      }
-      exports(exportName, exportCb);
+        }
+        try {
+          return await originalMethod.call(this, ...args);
+        } catch (e) {
+          REMOVE_EVENT_LOG: {
+            if (!GlobalData.EnablePrettyPrint) return;
+            console.error("------- EVENT ERROR --------");
+            console.error(`Call to ${eventName} errored`);
+            console.error(`Data: ${JSON.stringify(args)}`);
+            console.error(`Error: ${e}`);
+            console.error("------- END EVENT ERROR --------");
+          }
+        }
+      });
     });
   }, "actualDecorator");
 }
-__name(Exports, "Exports");
+__name(CfxEvent, "CfxEvent");
 function Event(eventName) {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
@@ -80,15 +78,31 @@ function Event(eventName) {
   }, "actualDecorator");
 }
 __name(Event, "Event");
-const CfxEvent = Event;
 function NetEvent(eventName, remoteOnly = true) {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
       throw new Error("NetEvent does not work on private methods, please mark the method as public");
     }
     context.addInitializer(function() {
+      const _t = this;
       onNet(eventName, async (...args) => {
         const src = source;
+        if (_t.__permissionMap) {
+          const permissions = _t.__permissionMap.get(context.name);
+          if (permissions) {
+            let hasPermission = false;
+            for (const perm of permissions) {
+              if (IsPlayerAceAllowed(src, perm)) {
+                hasPermission = true;
+                break;
+              }
+            }
+            if (!hasPermission) {
+              emit("@nativewrappers:no_permission", { eventName, method: context.name });
+              return;
+            }
+          }
+        }
         try {
           $CLIENT: {
             if (GlobalData.IS_CLIENT && remoteOnly && source !== 65535) {
@@ -112,97 +126,38 @@ function NetEvent(eventName, remoteOnly = true) {
   }, "actualDecorator");
 }
 __name(NetEvent, "NetEvent");
-function NuiEvent(eventName) {
+function NuiEvent(eventName, dontErrorWhenCbIsntInvoked = false) {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
       throw new Error("NuiEvent does not work on private methods, please mark the method as public");
     }
     context.addInitializer(function() {
-      RegisterNuiCallback(eventName, (...args) => {
-        return originalMethod.call(this, ...args);
-      });
-    });
-  }, "actualDecorator");
-}
-__name(NuiEvent, "NuiEvent");
-const get_convar_fn = /* @__PURE__ */ __name((con_var_type) => {
-  switch (con_var_type) {
-    case 0 /* String */:
-      return GetConvar;
-    case 1 /* Integer */:
-      return GetConvarInt;
-    case 2 /* Float */:
-      return GetConvarFloat;
-    case 3 /* Boolean */:
-      return GetConvarBool;
-    // needed so typescript wont complain about "unreachable code" for the error below
-    default:
-  }
-  throw new Error("Got invalid ConVarType");
-}, "get_convar_fn");
-function ConVar(name, is_floating_point, deserialize) {
-  return /* @__PURE__ */ __name(function actualDecorator(_initialValue, context, ..._args) {
-    if (context.private) {
-      throw new Error("ConVar does not work on private types, please mark the field as public");
-    }
-    context.addInitializer(function() {
-      const t = this;
-      const default_value = Reflect.get(t, context.name);
-      const default_type = typeof default_value;
-      let con_var_type = null;
-      if (default_type === "number") {
-        if (is_floating_point || !Number.isInteger(default_value)) {
-          con_var_type = 2 /* Float */;
-        } else {
-          con_var_type = 1 /* Integer */;
+      RegisterNuiCallback(eventName, async (data, cb) => {
+        let wasInvoked = false;
+        const cbWrapper = /* @__PURE__ */ __name((args) => {
+          wasInvoked = true;
+          cb(args);
+        }, "cbWrapper");
+        const retData = await originalMethod.call(this, data, cbWrapper);
+        if (!wasInvoked && !retData) {
+          if (dontErrorWhenCbIsntInvoked) return;
+          throw new Error(
+            `Error in NuiEvent ${eventName} '@NuiEvent' expects you to return data in your callback, or to return from the function call`
+          );
+        }
+        if (!wasInvoked) {
+          cb(retData);
         }
-      } else if (default_type === "boolean") {
-        con_var_type = 3 /* Boolean */;
-      } else if (default_type === "string") {
-        con_var_type = 0 /* String */;
-      }
-      if (!deserialize && con_var_type === null) {
-        throw new Error(
-          `Failed to determine what to use to deserialize '${name}' was for var had type '${default_type}' which can't be deserialized without providing your own deserialize function.`
-        );
-      }
-      if (con_var_type === null) {
-        con_var_type = 0 /* String */;
-      }
-      const con_var_fn = get_convar_fn(con_var_type);
-      const get_convar_value = /* @__PURE__ */ __name(() => {
-        const data = con_var_fn(name, default_value);
-        return deserialize ? deserialize(data) : data;
-      }, "get_convar_value");
-      Reflect.set(t, context.name, get_convar_value());
-      AddConvarChangeListener(name, () => {
-        Reflect.set(t, context.name, get_convar_value());
-      });
-    });
-  }, "actualDecorator");
-}
-__name(ConVar, "ConVar");
-function SetTick() {
-  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
-    if (context.private) {
-      throw new Error("SetTick does not work on private types, please mark the field as public");
-    }
-    context.addInitializer(function() {
-      setTick(async () => {
-        await originalMethod.call(this);
       });
     });
   }, "actualDecorator");
 }
-__name(SetTick, "SetTick");
+__name(NuiEvent, "NuiEvent");
 export {
+  Binding,
   CfxEvent,
-  ConVar,
-  ConVarType,
   DisablePrettyPrint,
   Event,
-  Exports,
   NetEvent,
-  NuiEvent,
-  SetTick
+  NuiEvent
 };

package/common/decors/Exports.d.ts

@@ -0,0 +1 @@
+export declare function Exports(exportName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common/decors/Exports.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+const AsyncFunction = (async () => {
+}).constructor;
+function Exports(exportName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Exports does not work on private methods, please mark the method as public");
+    }
+    context.addInitializer(function() {
+      let exportCb;
+      if (originalMethod instanceof AsyncFunction) {
+        exportCb = /* @__PURE__ */ __name(async (...args) => {
+          try {
+            return await originalMethod.call(this, ...args);
+          } catch (err) {
+            REMOVE_EVENT_LOG: {
+              if (!GlobalData.EnablePrettyPrint) return;
+              console.error("------- EXPORT ERROR --------");
+              console.error(`Call to ${exportName} errored`);
+              console.error(`Data: ${JSON.stringify(args)}`);
+              console.error(`Error: ${err}`);
+              console.error("------- END EXPORT ERROR --------");
+            }
+            throw err;
+          }
+        }, "exportCb");
+      } else {
+        exportCb = /* @__PURE__ */ __name((...args) => {
+          try {
+            return originalMethod.call(this, ...args);
+          } catch (err) {
+            REMOVE_EVENT_LOG: {
+              if (!GlobalData.EnablePrettyPrint) return;
+              console.error("------- EXPORT ERROR --------");
+              console.error(`Call to ${exportName} errored`);
+              console.error(`Data: ${JSON.stringify(args)}`);
+              console.error(`Error: ${err}`);
+              console.error("------- END EXPORT ERROR --------");
+            }
+            throw err;
+          }
+        }, "exportCb");
+      }
+      exports(exportName, exportCb);
+    });
+  }, "actualDecorator");
+}
+__name(Exports, "Exports");
+export {
+  Exports
+};

package/common/decors/Permissions.d.ts

@@ -0,0 +1,3 @@
+export declare function RestrictToGroupAce(groupAceName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function RestrictToJobAce(jobAce: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function RestrictToAce(aceName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common/decors/Permissions.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+const addAcePermission = /* @__PURE__ */ __name((aceName, context) => {
+  context.addInitializer(function() {
+    const _t = this;
+    _t.__permissionMap = _t.__permissionMap ?? /* @__PURE__ */ new Map();
+    const ace_list = _t.__permissionMap.get(context.name);
+    if (ace_list) {
+      ace_list.add(aceName);
+    } else {
+      _t.__permissionMap.set(context.name, /* @__PURE__ */ new Set([aceName]));
+    }
+  });
+}, "addAcePermission");
+function RestrictToGroupAce(groupAceName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Exports does not work on private methods, please mark the method as public");
+    }
+    const groupAce = `group.${groupAceName}`;
+    addAcePermission(groupAce, context);
+  }, "actualDecorator");
+}
+__name(RestrictToGroupAce, "RestrictToGroupAce");
+function RestrictToJobAce(jobAce) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Exports does not work on private methods, please mark the method as public");
+    }
+    const groupAce = `job.${jobAce}`;
+    addAcePermission(groupAce, context);
+  }, "actualDecorator");
+}
+__name(RestrictToJobAce, "RestrictToJobAce");
+function RestrictToAce(aceName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Exports does not work on private methods, please mark the method as public");
+    }
+    addAcePermission(aceName, context);
+  }, "actualDecorator");
+}
+__name(RestrictToAce, "RestrictToAce");
+export {
+  RestrictToAce,
+  RestrictToGroupAce,
+  RestrictToJobAce
+};

package/common/decors/Resources.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Called whenever the specified resource is started, this will be called once on once on resource start if the resource is started.
+ */
+export declare function OnResourceStart(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Called whenever the specified resource is stopped.
+ */
+export declare function OnResoureStop(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common/decors/Resources.js

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Event } from "./Events";
+class ResourceWrapper {
+  static {
+    __name(this, "ResourceWrapper");
+  }
+  #on_resource_start = /* @__PURE__ */ new Map();
+  #on_resource_stop = /* @__PURE__ */ new Map();
+  #add_or_init(resource_fn_map, resource_name, fn) {
+    const fn_array = resource_fn_map.get(resource_name);
+    if (fn_array) {
+      fn_array.push(fn);
+    } else {
+      resource_fn_map.set(resource_name, [fn]);
+    }
+  }
+  /**
+   * Adds a function to get called whenever a resource is started
+   * @param resource_name The resource name to add to the start listener.
+   * @param fn The function to call
+   */
+  add_to_resource_start(resource_name, fn) {
+    this.#add_or_init(this.#on_resource_start, resource_name, fn);
+  }
+  /**
+   * Adds a function to get called whenever a resource is stopped
+   * @param resource_name The resource name to add to the stop listener.
+   * @param fn The function to call
+   */
+  add_to_resource_stop(resource_name, fn) {
+    this.#add_or_init(this.#on_resource_stop, resource_name, fn);
+  }
+  #call_for_resource(resource_fn_map, resource_name) {
+    const functions = resource_fn_map.get(resource_name);
+    if (functions) {
+      for (const fn of functions) {
+        fn();
+      }
+    }
+  }
+  @Event("onResourceStart")
+  on_resource_start(resource_name) {
+    this.#call_for_resource(this.#on_resource_start, resource_name);
+  }
+  @Event("onResourceStop")
+  on_resource_stop(resource_name) {
+    this.#call_for_resource(this.#on_resource_stop, resource_name);
+  }
+}
+if (!globalThis.RESOURCE_WRAPPER) {
+  globalThis.RESOURCE_WRAPPER = new ResourceWrapper();
+}
+const RESOURCE_WRAPPER = globalThis.RESOURCE_WRAPPER;
+function OnResourceStart(resource = GetCurrentResourceName()) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnResourceStart does not work on private types, please mark the field as public");
+    }
+    context.addInitializer(() => {
+      if (GetResourceState(resource) === "started") {
+        setImmediate(() => originalMethod.call());
+      }
+      RESOURCE_WRAPPER.add_to_resource_start(resource, originalMethod);
+    });
+  }, "actualDecorator");
+}
+__name(OnResourceStart, "OnResourceStart");
+function OnResoureStop(resource = GetCurrentResourceName()) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnResourceStop does not work on private types, please mark the field as public");
+    }
+    context.addInitializer(() => {
+      RESOURCE_WRAPPER.add_to_resource_stop(resource, originalMethod);
+    });
+  }, "actualDecorator");
+}
+__name(OnResoureStop, "OnResoureStop");
+export {
+  OnResourceStart,
+  OnResoureStop
+};

package/common/decors/Ticks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets called per server/client tick, this is asyncronous though, if you await
+ * in it, it will not be called until whatever was being awaited resolves.
+ */
+export declare function SetTick(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Gets called on the frame after the class is initialized.
+ */
+export declare function SetImmediate(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;