@nativewrappers/redm 0.0.80 → 0.0.82

package/common/utils/enumValues.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* enumValues(enumObj) {
+  let isStringEnum = true;
+  for (const property in enumObj) {
+    if (typeof enumObj[property] === "number") {
+      isStringEnum = false;
+      break;
+    }
+  }
+  for (const property in enumObj) {
+    if (isStringEnum || typeof enumObj[property] === "number") {
+      yield enumObj[property];
+    }
+  }
+}
+__name(enumValues, "enumValues");
+export {
+  enumValues
+};

package/common/utils/getStringFromUInt8Array.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getStringFromUInt8Array = /* @__PURE__ */ __name((buffer, start, end) => String.fromCharCode(...buffer.slice(start, end)).replace(/\u0000/g, ""), "getStringFromUInt8Array");
+export {
+  getStringFromUInt8Array
+};

package/common/utils/getUInt32FromUint8Array.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getUInt32FromUint8Array = /* @__PURE__ */ __name((buffer, start, end) => new Uint32Array(buffer.slice(start, end).buffer)[0], "getUInt32FromUint8Array");
+export {
+  getUInt32FromUint8Array
+};

package/entities/BaseEntity.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from "../common/utils";
+import { Vector3 } from "../common/utils/Vector";
 export declare class BaseEntity {
     private handle;
     constructor(entHandle: number);

package/entities/BaseEntity.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "../common/utils/Vector";
+class BaseEntity {
+  static {
+    __name(this, "BaseEntity");
+  }
+  handle;
+  constructor(entHandle) {
+    this.handle = entHandle;
+  }
+  /**
+    * Replaces the current handle for the entity used on, this hsould be used sparringly, mainly
+    * in situations where you're going to reuse an entity over and over and don't want to make a
+    * new entity every time.
+    *
+    *  **WARNING**: This does no checks, if you provide it an invalid entity it will use it
+    *
+    * ```ts
+    * const REUSABLE_ENTITY = new Entity(entityHandle);
+    *
+    * onNet("entityHandler", (entNetId: number) => {
+    *  // if no net entity we should ignore
+    *  if (!NetworkDoesEntityExistWithNetworkId(entNetId)) return;
+    *
+    *  // Reuse our entity so we don't have to initialize a new one
+    *  REUSABLE_ENTITY.replaceHandle(NetworkGetEntityFromNetworkId(entNetId));
+    *  // Do something with REUSABLE_ENTITY entity
+    * })
+    ```
+    */
+  replaceHandle(newHandle) {
+    this.handle = newHandle;
+  }
+  /**
+   * @returns the network for the specified entity, this doesn't check if the entity is networked, you should use {@link BaseEntity.IsNetworked}
+   */
+  get NetworkId() {
+    return NetworkGetNetworkIdFromEntity(this.Handle);
+  }
+  /**
+   * @returns `true` if the current entity is networked, false otherwise
+   */
+  get IsNetworked() {
+    return NetworkGetEntityIsNetworked(this.Handle);
+  }
+  /**
+   * @returns Returns true if the entity handle is not 0 and exists in the game engine
+   */
+  get Exists() {
+    return this.handle !== 0 && DoesEntityExist(this.Handle);
+  }
+  /**
+   * @returns The entitys current handle.
+   */
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * @param amount the health to set the health to, setting to `0` will kill the entity, if using on a {@link Ped} you should check the MaxHealth before setting.
+   */
+  set Health(amount) {
+    SetEntityHealth(this.Handle, amount, 0);
+  }
+  /**
+   * @returns the amount of health the current {@link BaseEntity} has
+   */
+  get Health() {
+    return GetEntityHealth(this.Handle);
+  }
+  /**
+   * @returns the heading of the current {@link BaseEntity}
+   */
+  get Heading() {
+    return GetEntityHeading(this.Handle);
+  }
+  /**
+   * @param heading sets the entitys heading to the specified heading, this can be in the range of 0..360
+   */
+  set Heading(heading) {
+    SetEntityHeading(this.Handle, heading);
+  }
+  /**
+   * @returns the position of the current Entity
+   */
+  get Position() {
+    return Vector3.fromArray(GetEntityCoords(this.handle, true, true));
+  }
+  /**
+   * You should (almost) always try to load the collisions before setting the entitys position if going a long distance.
+   * @param pos sets the position for the current ped
+   */
+  set Position(pos) {
+    SetEntityCoords(this.handle, pos.x, pos.y, pos.z, false, false, false, false);
+  }
+}
+export {
+  BaseEntity
+};

package/entities/Entity.d.ts

@@ -1,6 +1,6 @@
+import type { Vector3 } from "../common/utils/Vector";
 import { type BoneIndex, EntityType, ForceType } from "../enums/Entity";
 import type { Throwable } from "../types/Throwable";
-import { type Vector3 } from "../utils";
 import { BaseEntity } from "./BaseEntity";
 export declare class Entity extends BaseEntity {
     constructor(handle: number);

package/entities/Entity.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { _N } from "redm/utils/Native";
+import { EntityType, ForceType } from "../enums/Entity";
+import { BaseEntity } from "./BaseEntity";
+class Entity extends BaseEntity {
+  static {
+    __name(this, "Entity");
+  }
+  // NOTE: There is nothing stopping you from using creating an invalid entity, you should do your own due-diligence
+  constructor(handle) {
+    super(handle);
+  }
+  addTrackingTrails() {
+    _N("0x1AD922AB5038DEF3", this.Handle);
+  }
+  get EntityType() {
+    return GetEntityType(this.Handle);
+  }
+  /**
+   * @param direction - the direction to apply the force towards
+   * @param offset - the offset to apply the force to
+   * @param forceType - the force type to apply
+   * @param boneIndex - the boneIndex to apply the force to, or 0
+   * @param isDirectional - whether the direction is relational?
+   * @param ignoreUpVec - ?
+   * @param isForceRel - whether to multiply the force by the object mass & acceleration
+   */
+  applyForce(direction, offset, forceType = ForceType.MinForce, boneIndex = 0, isDirectional = false, ignoreUpVec = true, isForceRel = true) {
+    const d = direction;
+    const o = offset;
+    ApplyForceToEntity(
+      this.Handle,
+      forceType,
+      d.x,
+      d.y,
+      d.z,
+      o.x,
+      o.y,
+      o.z,
+      boneIndex,
+      isDirectional,
+      ignoreUpVec,
+      isForceRel,
+      false,
+      true
+    );
+  }
+  /**
+   * @param direction - the direction to apply the force towards
+   * @param forceType - the force type to use
+   * @param isDirectional - whether the direction is local?
+   * @param isForceRel - whether to multiply the force by the object mass & acceleration
+   */
+  applyForceToCenter(direction, forceType = ForceType.MinForce, isDirectional = false, isForceRel = true) {
+    const d = direction;
+    ApplyForceToEntityCenterOfMass(this.Handle, forceType, d.x, d.y, d.z, false, isDirectional, isForceRel, false);
+  }
+  /**
+   * @param tgtEntity - the entity to attach to the {@Entity}
+   * @param pos - the position offset
+   * @param rot - the rotation to apply to the entity
+   * @param boneIndex - the bone to attach the entity to, or 0 for the center of the entity
+   * @param enableCollision - whether the entity should have collision enabled
+   * @param useSoftPinning - when false the entity will not detach from the {@Entity}
+   * @param vertexIndex -  ?
+   * @param fixedRot - ?
+   * @throws Error if tgtEntity and {@Entity} are the same entity
+   */
+  attachTo(tgtEntity, pos, rot, boneIndex = 0, enableCollision = true, useSoftPinning = false, vertexIndex = 0, fixedRot = true) {
+    if (tgtEntity.Handle === this.Handle) {
+      throw new Error("tgtEntity had the same handle as the current entity, attaching an entity to itself will crash");
+    }
+    const p = pos;
+    const r = rot;
+    AttachEntityToEntity(
+      tgtEntity.Handle,
+      this.Handle,
+      boneIndex,
+      p.x,
+      p.y,
+      p.z,
+      r.x,
+      r.y,
+      r.z,
+      false,
+      useSoftPinning,
+      enableCollision,
+      this.EntityType === EntityType.Ped,
+      vertexIndex,
+      fixedRot,
+      false,
+      false
+    );
+  }
+}
+export {
+  Entity
+};

package/entities/Ped.d.ts

@@ -1,10 +1,10 @@
 import { Attributes } from "../Attribute";
 import type { eDamageCleanliness, KnockOffVehicle, TamingState } from "../enums/Ped";
 import type { VehicleSeat } from "../enums/VehicleSeat";
-import { type Vector3 } from "../utils";
 import { BaseEntity } from "./BaseEntity";
 import { Vehicle } from "./Vehicle";
 import type { Player } from "./Player";
+import type { Vector3 } from "../common/utils/Vector";
 export declare class Ped extends BaseEntity {
     private attributes;
     constructor(handle: number);

package/entities/Ped.js

@@ -0,0 +1,336 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Attributes } from "../Attribute";
+import { BaseEntity } from "./BaseEntity";
+import { Vehicle } from "./Vehicle";
+import { _N } from "redm/utils/Native";
+class Ped extends BaseEntity {
+  static {
+    __name(this, "Ped");
+  }
+  attributes;
+  constructor(handle) {
+    super(handle);
+  }
+  /**
+   * Blocks scenarios inbetween the specified vectors
+   * @todo Move to Game
+   * @param vec1
+   * @param vec2
+   * @param blockingFlags you can find blocking flags [here](https://github.com/Halen84/RDR3-Native-Flags-And-Enums/blob/main/ADD_SCENARIO_BLOCKING_AREA/README.md)
+   * @returns the scenarioId that can be used in {@link removeScenarioBlock} to unblock
+   */
+  static blockScenariosInArea(vec1, vec2, blockingFlags) {
+    return AddScenarioBlockingArea(
+      vec1.x,
+      vec1.y,
+      vec1.z,
+      vec2.x,
+      vec2.y,
+      vec2.z,
+      true,
+      blockingFlags
+    );
+  }
+  /**
+   * Removes the blocking of scenarios in the specified area
+   * @param scenarioId the number returned from {@link blockScenariosInArea}
+   */
+  static removeScenarioBlock(scenarioId) {
+    RemoveScenarioBlockingArea(scenarioId, false);
+  }
+  /**
+   * While this increases the peds max health, if used on a player it wont increase the max core value on the hud
+   */
+  set MaxHealth(amount) {
+    SetPedMaxHealth(this.Handle, amount);
+  }
+  /**
+   * @returns the maximum health of the ped
+   */
+  get MaxHealth() {
+    return GetPedMaxHealth(this.Handle);
+  }
+  /**
+   * @returns the {@link Attributes} for the current ped
+   */
+  get Attributes() {
+    if (this.attributes) return this.attributes;
+    return this.attributes = new Attributes(this);
+  }
+  get InVehicle() {
+    return IsPedInAnyVehicle(this.Handle, true);
+  }
+  get IsInjured() {
+    return IsPedInjured(this.Handle);
+  }
+  get IsFatallyInjured() {
+    return IsPedFatallyInjured(this.Handle);
+  }
+  get IsPlayer() {
+    return IsPedAPlayer(this.Handle);
+  }
+  get IsShooting() {
+    return IsPedShooting(this.Handle);
+  }
+  get Accuracy() {
+    return GetPedAccuracy(this.Handle);
+  }
+  set Accuracy(accuracy) {
+    SetPedAccuracy(this.Handle, accuracy);
+  }
+  get CanBeKnockedOffVehicle() {
+    return CanKnockPedOffVehicle(this.Handle);
+  }
+  get IsMale() {
+    return IsPedMale(this.Handle);
+  }
+  get IsHuman() {
+    return IsPedHuman(this.Handle);
+  }
+  get IsOnTopOfVehicle() {
+    return IsPedOnVehicle(this.Handle, false);
+  }
+  get Vehicle() {
+    const vehicle = GetVehiclePedIsIn(this.Handle, false);
+    if (vehicle === 0) {
+      return null;
+    }
+    return new Vehicle(vehicle);
+  }
+  /**
+   * @returns the last mount that this ped was on, or null if it doesn't exist
+   */
+  get Mount() {
+    const pedId = _N("0x4C8B59171957BCF7", this.Handle, Citizen.resultAsInteger());
+    return pedId ? new Ped(pedId) : null;
+  }
+  /**
+   * returns the horse that this ped is leading
+   */
+  get LeadingHorse() {
+    const pedId = _N("0x693126B5D0457D0D", this.Handle, Citizen.resultAsInteger());
+    return pedId ? new Ped(pedId) : null;
+  }
+  /**
+   * returns the owner of the current animal
+   */
+  get Owner() {
+    const pedId = _N("0xF103823FFE72BB49", this.Handle, Citizen.resultAsInteger());
+    return pedId ? new Ped(pedId) : null;
+  }
+  get TamingState() {
+    return _N("0x454AD4DA6C41B5BD", this.Handle, Citizen.resultAsInteger());
+  }
+  get IsInteractingWithAnimal() {
+    return _N("0x7FC84E85D98F063D", this.Handle, Citizen.resultAsInteger());
+  }
+  get IsSittingInAnyVehicle() {
+    return IsPedSittingInAnyVehicle(this.Handle);
+  }
+  get IsPlantingBomb() {
+    return IsPedPlantingBomb(this.Handle);
+  }
+  get IsInAnyBoat() {
+    return IsPedInAnyBoat(this.Handle);
+  }
+  get IsInAnyHeli() {
+    return IsPedInAnyHeli(this.Handle);
+  }
+  get IsInAnyPlane() {
+    return IsPedInAnyPlane(this.Handle);
+  }
+  get IsInFlyingVehicle() {
+    return IsPedInFlyingVehicle(this.Handle);
+  }
+  get IsFalling() {
+    return IsPedFalling(this.Handle);
+  }
+  get IsSliding() {
+    return _N("0xD6740E14E4CEFC0B", this.Handle, Citizen.resultAsInteger());
+  }
+  get IsJumping() {
+    return IsPedJumping(this.Handle);
+  }
+  get IsClimbing() {
+    return IsPedClimbing(this.Handle);
+  }
+  get IsClimbingLadder() {
+    return _N("0x59643424B68D52B5", this.Handle, Citizen.resultAsInteger());
+  }
+  get IsVaulting() {
+    return IsPedVaulting(this.Handle);
+  }
+  get IsDiving() {
+    return IsPedDiving(this.Handle);
+  }
+  get IsOpeningADoor() {
+    return IsPedOpeningADoor(this.Handle);
+  }
+  set SeeingRange(value) {
+    SetPedSeeingRange(this.Handle, value);
+  }
+  set HearingRange(value) {
+    SetPedHearingRange(this.Handle, value);
+  }
+  get IsStealthed() {
+    return GetPedStealthMovement(this.Handle);
+  }
+  get IsJacking() {
+    return IsPedJacking(this.Handle);
+  }
+  get IsStunned() {
+    return IsPedBeingStunned(this.Handle, 0);
+  }
+  get IsBeingJacked() {
+    return IsPedBeingJacked(this.Handle);
+  }
+  get IsInCombatRoll() {
+    return _N("0xC48A9EB0D499B3E5", this.Handle, Citizen.resultAsInteger());
+  }
+  get CrouchMovement() {
+    return _N("0xD5FE956C70FF370B", this.Handle, Citizen.resultAsInteger());
+  }
+  /**
+   * returns true if {@link DamageCleanliness} was ever lower than {@link eDamageCleanliness.Good}
+   */
+  get IsDamaged() {
+    return _N("0x6CFC373008A1EDAF", this.Handle, Citizen.resultAsInteger());
+  }
+  set IsDamaged(damaged) {
+    _N("0xDACE03C65C6666DB", this.Handle, damaged);
+  }
+  get DamageCleanliness() {
+    return _N("0x88EFFED5FE8B0B4A", this.Handle, Citizen.resultAsInteger());
+  }
+  set DamageCleanliness(cleanliness) {
+    _N("0x7528720101A807A5", this.Handle, cleanliness);
+  }
+  set DefenseModifier(amount) {
+    _N("0x9B6808EC46BE849B", this.Handle, amount);
+  }
+  set CanBeTargeted(toggle) {
+    SetPedCanBeTargetted(this.Handle, toggle);
+  }
+  // TODO: Team class wrapper
+  // TODO: Bone wrapper `GET_PED_LAST_DAMAGE_BONE`
+  /**
+   * returns the ped who jacked this ped
+   */
+  getJacker() {
+    return new Ped(GetPedsJacker(this.Handle));
+  }
+  setCrouchMovement(state, immediately = false) {
+    _N("0x7DE9692C6F64CFE8", this.Handle, state, 0, immediately);
+  }
+  canBeTargetedByPlayer(player, toggle) {
+    SetPedCanBeTargettedByPlayer(this.Handle, player.Handle, toggle);
+  }
+  clearLastBoneDamage() {
+    ClearPedLastDamageBone(this.Handle);
+  }
+  set OwnsAnimal(animal) {
+    _N("0x931B241409216C1F", this.Handle, animal.Handle, false);
+  }
+  isInteractionPossible(animal) {
+    return _N("0xD543D3A8FDE4F185", this.Handle, animal.Handle, Citizen.resultAsInteger());
+  }
+  isOnVehicle(vehicle) {
+    return IsPedOnSpecificVehicle(this.Handle, vehicle.Handle);
+  }
+  isSittingInVehicle(vehicle) {
+    return IsPedSittingInVehicle(this.Handle, vehicle.Handle);
+  }
+  warpOutOfVehicle() {
+    _N("0xE0B61ED8BB37712F", this.Handle);
+  }
+  /**
+   * puts the ped onto the specified mount
+   * @param targetPed the horse to put the ped on
+   * @param seatIndex the seat index to put the ped on
+   */
+  setOntoMount(targetPed, seatIndex) {
+    _N("0x028F76B6E78246EB", this.Handle, targetPed.Handle, seatIndex, true);
+  }
+  removeFromMount() {
+    _N("0x5337B721C51883A9", this.Handle, true, true);
+  }
+  /**
+   * Sets the ped into the specified vehicle
+   * @param vehicle the vehicle to put the ped into
+   * @param seatIndex the seat index to put the ped into
+   */
+  setIntoVehicle(vehicle, seatIndex) {
+    SetPedIntoVehicle(this.Handle, vehicle.Handle, seatIndex);
+  }
+  /**
+   * kills the ped and optionally sets the killer
+   * @param killer the entity that killed the ped
+   */
+  killPed(killer) {
+    SetEntityHealth(this.Handle, 0, killer ? killer.Handle : 0);
+  }
+  damage(amount, boneId = 0, killer) {
+    ApplyDamageToPed(this.Handle, amount, 0, boneId, killer ? killer.Handle : 0);
+  }
+  /**
+   * this returns a different type then the getter so we can't use set, maybe ts will fix soon (tm)
+   * @param state how hard it will be to knock a ped off their vehicle
+   */
+  setCanBeKnockedOffVehicle(state) {
+    SetPedCanBeKnockedOffVehicle(this.Handle, state);
+  }
+  /**
+   * Removes the specified ped if its not a player entity
+   */
+  delete() {
+    SetEntityAsMissionEntity(this.Handle, true, true);
+    DeletePed(this.Handle);
+  }
+  /**
+   * creates a clone of the ped
+   * @param network if the ped should be a networked entity
+   * @param bScriptHostPed whether to register the ped as pinned to the script host in the R* network model.
+   * @param copyHeadBlend whether to copy the peds head blend
+   * @returns the cloned ped
+   */
+  clone(network, bScriptHostPed, copyHeadBlend) {
+    return new Ped(ClonePed(this.Handle, network, bScriptHostPed, copyHeadBlend));
+  }
+  /**
+   * clones the ped onto the target ped
+   * @param targetPed the ped to clone onto
+   */
+  cloneTo(targetPed) {
+    ClonePedToTarget(this.Handle, targetPed.Handle);
+  }
+  /**
+   * @param amount - the amount of armour to add to the ped
+   */
+  addArmour(amount) {
+    AddArmourToPed(this.Handle, amount);
+  }
+  applyDamage(damageAmount, boneId = 0, pedKiller = null) {
+    ApplyDamageToPed(this.Handle, damageAmount, 0, boneId, pedKiller ? pedKiller.Handle : 0);
+  }
+  /**
+   * @param damagePack - the damage decal to apply see [here](https://github.com/femga/rdr3_discoveries/blob/master/peds_customization/ped_decals.lua) for more documentation
+   * @param damage - the damage to apply
+   * @param mult - the multiplier?
+   */
+  applyDamagePack(damagePack, damage, mult) {
+    ApplyPedDamagePack(this.Handle, damagePack, damage, mult);
+  }
+  get CurrentVehicle() {
+    const veh = GetVehiclePedIsIn(this.Handle, false);
+    if (veh === 0) return null;
+    return new Vehicle(veh);
+  }
+  // No documentation
+  // applyBloodSpecific() {
+  // 	ApplyPedBloodSpecific
+  // }
+}
+export {
+  Ped
+};

package/entities/Pickup.d.ts

@@ -0,0 +1,4 @@
+export declare class Pickup {
+    handle: number;
+    constructor(handle: number);
+}

package/entities/Pickup.js

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

package/entities/Player.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GameConstants } from "redm/GameConstants";
+import { _N } from "../utils/Native";
+const handleUpgrade = /* @__PURE__ */ __name((name, amount) => {
+  const b1 = new ArrayBuffer(8 * 24);
+  const a2 = new DataView(b1);
+  const b2 = new ArrayBuffer(8 * 12);
+  const a3 = new DataView(b2);
+  _N("0xCB5D11F9508A928D", 1, a2, a3, GetHashKey(name), 1084182731, amount, 752097756);
+}, "handleUpgrade");
+class Player {
+  static {
+    __name(this, "Player");
+  }
+  handle;
+  static fromPedHandle(handle) {
+    return new Player(NetworkGetPlayerIndexFromPed(handle));
+  }
+  /**
+   * Gets the player from the specified {@param serverId}
+   * @returns the player object, or null if the player didn't exist
+   */
+  static fromServerId(serverId) {
+    if (serverId === GameConstants.ServerId) {
+      return GameConstants.Player;
+    }
+    const player = GetPlayerFromServerId(serverId);
+    if (player === -1) return null;
+    return new Player(player);
+  }
+  /**
+   * @param handle the player handle
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * Adds the amount of stamina player has on the hud
+   * @param amount the amount of upgrade to give 6 is half the bar while 12 is the full bar
+   */
+  addStaminaUpgrade(amount) {
+    handleUpgrade("UPGRADE_STAMINA_TANK_1", amount);
+  }
+  addHealthUpgrade(amount) {
+    handleUpgrade("UPGRADE_HEALTH_TANK_1", amount);
+  }
+  addDeadeyeUpgrade(amount) {
+    handleUpgrade("UPGRADE_DEADEYE_TANK_1", amount);
+  }
+}
+export {
+  Player
+};

package/entities/Prop.js

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