Roblox/luau_corpus huggingface dataset:
--[=[
	@return Promise
	Starts Knit. Should only be called once.

	Optionally, `KnitOptions` can be passed in order to set
	Knit's custom configurations.

	:::caution
	Be sure that all services have been created _before_
	calling `Start`. Services cannot be added later.
	:::

	```lua
	Knit.Start():andThen(function()
		print("Knit started!")
	end):catch(warn)
	```
	
	Example of Knit started with options:
	```lua
	Knit.Start({
		Middleware = {
			Inbound = {
				function(player, args)
					print("Player is giving following args to server:", args)
					return true
				end
			},
		},
	}):andThen(function()
		print("Knit started!")
	end):catch(warn)
	```
]=]
function KnitServer.Start(options: KnitOptions?)
	if started then
		return Promise.reject("Knit already started")
	end

	started = true

	if options == nil then
		selectedOptions = defaultOptions
	else
		assert(typeof(options) == "table", `KnitOptions should be a table or nil; got {typeof(options)}`)
		selectedOptions = options
		for k, v in defaultOptions do
			if selectedOptions[k] == nil then
				selectedOptions[k] = v
			end
		end
	end

	return Promise.new(function(resolve)
		local knitMiddleware = if selectedOptions.Middleware ~= nil then selectedOptions.Middleware else {}

		-- Bind remotes:
		for _, service in services do
			local middleware = if service.Middleware ~= nil then service.Middleware else {}
			local inbound = if middleware.Inbound ~= nil then middleware.Inbound else knitMiddleware.Inbound
			local outbound = if middleware.Outbound ~= nil then middleware.Outbound else knitMiddleware.Outbound
			service.Middleware = nil
			for k, v in service.Client do
				if type(v) == "function" then
					service.KnitComm:WrapMethod(service.Client, k, inbound, outbound)
				elseif v == SIGNAL_MARKER then
					service.Client[k] = service.KnitComm:CreateSignal(k, inbound, outbound)
				elseif type(v) == "table" and v[1] == PROPERTY_MARKER then
					service.Client[k] = service.KnitComm:CreateProperty(k, v[2], inbound, outbound)
				end
			end
		end

		-- Init:
		local promisesInitServices = {}
		for _, service in services do
			if type(service.KnitInit) == "function" then
				table.insert(
					promisesInitServices,
					Promise.new(function(r)
						debug.setmemorycategory(service.Name)
						service:KnitInit()
						r()
					end)
				)
			end
		end

		resolve(Promise.all(promisesInitServices))
	end):andThen(function()
		-- Start:
		for _, service in services do
			if type(service.KnitStart) == "function" then
				task.spawn(function()
					debug.setmemorycategory(service.Name)
					service:KnitStart()
				end)
			end
		end

		startedComplete = true
		onStartedComplete:Fire()

		task.defer(function()
			onStartedComplete:Destroy()
		end)

		-- Expose service remotes to everyone:
		knitRepServiceFolder.Parent = script.Parent
	end)
end
--[[
primaryWeaponSlot.ChildRemoved:Connect(function(newChild)
	weapon1Label.BackgroundColor3 = onColor
end)
secondaryWeaponSlot.ChildRemoved:Connect(function(newChild)
	weapon2Label.BackgroundColor3 = onColor
end)
tertiaryWeaponSlot.ChildRemoved:Connect(function(newChild)
	weapon3Label.BackgroundColor3 = onColor
end)
--]]
localPlayer.CharacterAdded:Connect(function(newCharacter)
	character = newCharacter
end)
--------------------------------CUSTOMIZABLE STUFF------------------------------------
local resetcooldown = 1200 -- how long it takes to let you rob again.
local timetodrill = 20 -- how long it takes to drill a deposit box
-- settings.AntiHumanoidDeletion and settings.ProtectHats have been superseded Workspace.RejectCharacterDeletions 

settings.AntiSpeed = true 			-- (Client-Sided) Attempts to detect speed exploits
settings.AntiBuildingTools = false	-- (Client-Sided) Attempts to detect any HopperBin(s)/Building Tools added to the client
settings.AntiAntiIdle = false 		-- (Client-Sided) Kick the player if they are using an anti-idle exploit. Highly useful for grinding/farming games
settings.ExploitGuiDetection = false 		-- (Client-Sided) If any exploit GUIs are found in the CoreGui the exploiter gets kicked (If you use StarterGui:SetCore("SendNotification") with an image this will kick you)
--Rescripted by Luckymaxer

Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")

Sounds = {
	CoilSound = Handle:WaitForChild("CoilSound"),
}

Gravity = 196.20
JumpHeightPercentage = 0.25

ToolEquipped = false

function GetAllConnectedParts(Object)
	local Parts = {}
	local function GetConnectedParts(Object)
		for i, v in pairs(Object:GetConnectedParts()) do
			local Ignore = false
			for ii, vv in pairs(Parts) do
				if v == vv then
					Ignore = true
				end
			end
			if not Ignore then
				table.insert(Parts, v)
				GetConnectedParts(v)
			end
		end
	end
	GetConnectedParts(Object)
	return Parts
end

function SetGravityEffect()
	if not GravityEffect or not GravityEffect.Parent then
		GravityEffect = Instance.new("BodyForce")
		GravityEffect.Name = "GravityCoilEffect"
		GravityEffect.Parent = Torso
	end
	local TotalMass = 0
	local ConnectedParts = GetAllConnectedParts(Torso)
	for i, v in pairs(ConnectedParts) do
		if v:IsA("BasePart") then
			TotalMass = (TotalMass + v:GetMass())
		end
	end
	local TotalMass = (TotalMass * 196.20 * (1 - JumpHeightPercentage))
	GravityEffect.force = Vector3.new(0, TotalMass, 0)
end

function HandleGravityEffect(Enabled)
	if not CheckIfAlive() then
		return
	end
	for i, v in pairs(Torso:GetChildren()) do
		if v:IsA("BodyForce") then
			v:Destroy()
		end
	end
	for i, v in pairs({ToolUnequipped, DescendantAdded, DescendantRemoving}) do
		if v then
			v:disconnect()
		end
	end
	if Enabled then
		CurrentlyEquipped = true
		ToolUnequipped = Tool.Unequipped:connect(function()
			CurrentlyEquipped = false
		end)
		SetGravityEffect()
		DescendantAdded = Character.DescendantAdded:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
		DescendantRemoving = Character.DescendantRemoving:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
	end
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Torso and Torso.Parent and Player and Player.Parent) and true) or false)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	Torso = Character:FindFirstChild("Torso") or Character:FindFirstChild("UpperTorso")
	Player = Players:GetPlayerFromCharacter(Character)
	if not CheckIfAlive() then
		return
	end
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HumanoidDied = Humanoid.Died:connect(function()
		if GravityEffect and GravityEffect.Parent then
			GravityEffect:Destroy()
		end
	end)
	Sounds.CoilSound:Play()
	HandleGravityEffect(true)
	ToolEquipped = true
end

function Unequipped()
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HandleGravityEffect(false)
	ToolEquipped = false
end

Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
--//Weight//--
local VehicleWeight = 1700 --{Weight of vehicle in KG}
local WeightDistribution = 60 --{To the rear}
--- DFStats
   DFUse.Value = DFUse1:GetAsync(Plr.UserId) or DFUse.Value
	   DFUse1:SetAsync(Plr.UserId, DFUse.Value)
      DFUse.Changed:connect(function()
	   DFUse1:SetAsync(Plr.UserId, DFUse.Value)
   end)
end)

game.Players.PlayerRemoving:connect(function(Player)
	DFUse1:SetAsync(Player.UserId, Player.DFStats.DFUse.Value)
end)
--Editable--
local ID = 10862419793  --Your animation ID!--
local RunningSpeed = 25 --Running speed--
local NormalSpeed = 16  --Normal speed/walkspeed--
local FieldOfView = 80  --Field of view when running--
local key = "LeftShift"  --Sprint/Run key--
--Front
fWheel.CustomPhysicalProperties = PhysicalProperties.new(_Tune.FWheelDensity,fWheel.CustomPhysicalProperties.Friction,fWheel.CustomPhysicalProperties.Elasticity,fWheel.CustomPhysicalProperties.FrictionWeight,fWheel.CustomPhysicalProperties.ElasticityWeight)
--[=[
	@within Matter

	:::info Topologically-aware function
	This function is only usable if called within the context of [`Loop:begin`](/api/Loop#begin).
	:::

	Utility for easy time-based throttling.

	Accepts a duration, and returns `true` if it has been that long since the last time this function returned `true`.
	Always returns `true` the first time.

	This function returns unique results keyed by script and line number. Additionally, uniqueness can be keyed by a
	unique value, which is passed as a second parameter. This is useful when iterating over a query result, as you can
	throttle doing something to each entity individually.

	```lua
	if useThrottle(1) then -- Keyed by script and line number only
		print("only prints every second")
	end

	for id, enemy in world:query(Enemy) do
		if useThrottle(5, id) then -- Keyed by script, line number, and the entity id
			print("Recalculate target...")
		end
	end
	```

	@param seconds number -- The number of seconds to throttle for
	@param discriminator? any -- A unique value to additionally key by
	@return boolean -- returns true every x seconds, otherwise false
]=]
local function useThrottle(seconds, discriminator)
	local storage = topoRuntime.useHookState(discriminator, cleanup)

	if storage.time == nil or os.clock() - storage.time >= seconds then
		storage.time = os.clock()
		storage.expiry = os.clock() + seconds
		return true
	end

	return false
end

return useThrottle
--[=[
	@param name string
	@param enums {string}
	@return EnumList
	Constructs a new EnumList.

	```lua
	local directions = EnumList.new("Directions", {
		"Up",
		"Down",
		"Left",
		"Right",
	})

	local direction = directions.Up
	```
]=]
function EnumList.new(name: string, enums: EnumNames)
	assert(type(name) == "string", "Name string required")
	assert(type(enums) == "table", "Enums table required")
	local self = setmetatable({}, EnumList)
	self[LIST_KEY] = {}
	self[NAME_KEY] = name
	for i, enumName in ipairs(enums) do
		assert(type(enumName) == "string", "Enum name must be a string")
		local enumItem = CreateEnumItem(enumName, i, self)
		self[enumName] = enumItem
		table.insert(self[LIST_KEY], enumItem)
	end
	table.freeze(self)
	return self
end
---Strobe SCRIPT, DO NOT EDIT!---


for i,v in pairs(game.workspace.PLights:GetChildren()) do
	spawn(function()
		while true do
			v.MLSelling.Dimmer:Invoke(180)
			wait(0.005)
			v.MLSelling.Dimmer:Invoke(0)
			wait(0.005)

		end
	end)
end
---------------------------------------------------------------------------------------

local customMenuFieldOfView = defaultMenuFieldOfView * configuration.MenuFieldOfView.Value
local customMenuBlurIntesity = defaultMenuBlurIntensity / configuration.MenuBlurIntensity.Value

local customMenuMusicVolume = defaultMenuMusicVolume * configuration.MenuMusicVolume.Value
local customGameMusicVolume = defaultGameMusicVolume * configuration.GameMusicVolume.Value
-- Properties

BillboardGui.Parent = script.Parent.Parent.Parent.OwnerPart
BillboardGui.LightInfluence = 1
BillboardGui.Size = UDim2.new(0, 200, 0, 50)
BillboardGui.StudsOffset = Vector3.new(0, 2, 0)
BillboardGui.MaxDistance =25

TextBox.Parent = BillboardGui
TextBox.BackgroundColor3 = Color3.new(1, 1, 1)
TextBox.BackgroundTransparency = 1
TextBox.Size = UDim2.new(0, 200, 0, 50)
TextBox.Font = Enum.Font.SourceSans
TextBox.Text = script.Parent.Value.Name..',S Car.'
TextBox.TextColor3 = Color3.new(0.929412, 0.109804, 1)
TextBox.TextScaled = true
TextBox.TextSize = 14
TextBox.TextWrapped = true
--[[**
		wraps a callback in an assert with checkArgs

		@param callback The function to wrap
		@param checkArgs The function to use to check arguments in the assert

		@returns A function that first asserts using checkArgs and then calls callback
	**--]]
	function t.wrap(callback, checkArgs)
		assert(checkWrap(callback, checkArgs))
		return function(...)
			assert(checkArgs(...))
			return callback(...)
		end
	end
end
--FireServer
script.Parent.OnServerEvent:connect(function(pl,Fnc,...)
	F[Fnc](...)
end)
--!strict
-- https://programming-idioms.org/idiom/19/reverse-a-list/1314/lua
type Array<T> = { [number]: any }
function reverse(t: Array<any>): Array<any>
	local n = #t
	local i = 1
	while i < n do
		t[i], t[n] = t[n], t[i]
		i = i + 1
		n = n - 1
	end
	return t
end

return reverse
--[[*
 * Helpers
 ]]

local function expandRange(args: Array<any>, options)
	if typeof(options.expandRange) == "function" then
		return options.expandRange(table.unpack(args), options)
	end

	Array.sort(args)
	local value = ("[%s]"):format(Array.join(args, "-"))

	local ok = pcall(function()
		--[[ eslint-disable-next-line no-new ]]
		RegExp(value)
	end)
	if not ok then
		return Array.join(
			Array.map(args, function(v)
				return utils.escapeRegex(v)
			end),
			".."
		)
	end

	return value
end
--------------------------------------------------------------
-- You DO NOT need to add yourself to any of these lists!!! --
--------------------------------------------------------------

local Owners={kill1773}					-- Can set SuperAdmins, & use all the commands
local SuperAdmins={kill1773}			-- Can set permanent admins, & shutdown the game
local Admins={kill1773}					-- Can ban, crash, & set Moderators/VIP
local Mods={killl1773}					-- Can kick, mute, & use most commands
local VIP={kill1773}					-- Can use nonabusive commands only on self

local Settings={
--[[

	LOWGames Studios
	Date: 27 October 2022
	by Elder
	
]]--

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1, p2)
	local v1 = nil;
	if type(p1) == "boolean" then
		v1 = "BoolValue";
	elseif type(p1) == "number" then
		v1 = "NumberValue";
	elseif type(p1) == "string" then
		v1 = "StringValue";
	elseif typeof(p1) == "BrickColor" then
		v1 = "BrickColorValue";
	elseif typeof(p1) == "CFrame" then
		v1 = "CFrameValue";
	elseif typeof(p1) == "Color3" then
		v1 = "Color3Value";
	elseif typeof(p1) == "Ray" then
		v1 = "RayValue";
	elseif typeof(p1) == "Vector3" then
		v1 = "Vector3Value";
	elseif typeof(p1) == "Instance" then
		v1 = "ObjectValue";
	end;
	if not v1 then
		u1.Print("Value type not supported", true);
		return;
	end;
	local v2 = Instance.new(v1);
	v2.Value = p1;
	if p2 then
		v2.Parent = p2;
	end;
	return v2;
end;
--Made by Luckymaxer

Model = script.Parent

Players = game:GetService("Players")
Debris = game:GetService("Debris")

Creator = Model:FindFirstChild("Creator")
Tool = Model:FindFirstChild("Tool")

function DestroyModel()
	Debris:AddItem(Model, 2)
end

if not Creator or not Creator.Value or not Creator.Value:IsA("Player") or not Creator.Value.Parent or not Tool or not Tool.Value or not Tool.Value.Parent then
	DestroyModel()
	return
end

Creator = Creator.Value
Tool = Tool.Value

Character = Creator.Character
if not Character then
	DestroyModel()
	return
end

Creator.Changed:connect(function(Property)
	if Property == "Parent" and not Creator.Parent then
		DestroyModel()
	end
end)

Character.Changed:connect(function(Property)
	if Property == "Parent" and not Character.Parent then
		DestroyModel()
	end
end)

Tool.Changed:connect(function(Property)
	if Property == "Parent" and (not Tool.Parent or (not Tool.Parent:IsA("Backpack") and not Players:GetPlayerFromCharacter(Tool.Parent))) then
		DestroyModel()
	end
end)
--EDIT BELOW----------------------------------------------------------------------
settings.PianoSoundRange = 25

settings.KeyAesthetics = true

settings.PianoSounds = {
		"269058581",
		"269058744",
		"269058842",
		"269058899",
		"269058974",
		"269059048"
}
--[=[
	Mounts children to the parent and returns an object which will cleanup and delete
	all children when removed.

	Note that this effectively recursively mounts children and their values, which is
	the heart of the reactive tree.

	```lua
	Blend.New "ScreenGui" {
		Parent = game.Players.LocalPlayer.PlayerGui;
		[Blend.Children] = {
			Blend.New "Frame" {
				Size = UDim2.new(1, 0, 1, 0);
				BackgroundTransparency = 0.5;
			};
		};
	};
	```

	Note since 6.14 you don't need to be explicit about [Blend.Children]. Any number-based
	index in the mounting process will be automatically inferred as children to mount.

	```lua
	Blend.New "ScreenGui" {
		Parent = game.Players.LocalPlayer.PlayerGui;

		Blend.New "Frame" {
			Size = UDim2.new(1, 0, 1, 0);
			BackgroundTransparency = 0.5;
		};
	};
	```

	Rules:

	* `{ Instance }` - Tables of instances are all parented to the parent
	* Brio<Instance> will last for the lifetime of the brio
	* Brio<Observable<Instance>> will last for the lifetime of the brio
		* Brio<Signal<Instance>> will also act as above
		* Brio<Promise<Instance>> will also act as above
		* Brio<{ Instance } will also act as above
	* Observable<Instance> will parent to the parent
		* Signal<Instance> will act as Observable<Instance>
		* ValueObject<Instance> will act as an Observable<Instance>
		* Promise<Instance> will act as an Observable<Instance>
	*  will parent all instances to the parent
	* Observables may emit non-observables (in form of Computed/Dynamic)
		* Observable<Brio<Instance>> will last for the lifetime of the brio, and parent the instance.
		* Observable<Observable<Instance>> occurs when computed returns a value.
	* ValueObject<Instance> will switch to the current value
	* function - Will be invoked as `func(parent)` and then the standard scheme will be applied

	Cleanup:
	* Instances will be cleaned up on unsubscribe

	@param parent Instance
	@param value any
	@return Observable
]=]
function Blend.Children(parent, value)
	assert(typeof(parent) == "Instance", "Bad parent")

	local observe = Blend._observeChildren(value, parent)

	if observe then
		return observe:Pipe({
			Rx.tap(function(child)
				child.Parent = parent;
			end);
		})
	else
		return Rx.EMPTY
	end
end
-- Set the rotation:
function CamLock.SetRotation(horizontal, vertical)
	SetRotation(horizontal, vertical)
end
--Change this section to add or remove admins by their UserID.
--Parts of the admin panel can be disabled for certain users.
--To find a player's ID, go to their profile and look in the address bar. The number there is your ID.
_G.panelAdmins = {
	[game.CreatorId] = "kick ban unban shutdown kill broadcast", --Gives the place owner (likely you) full access
	[1199573361] = "kick ban unban shutdown kill broadcast",
	[67890] = "kick ban unban"
}
--[[

	streamable = Streamable.new(parent: Instance, childName: string)

	streamable:Observe(handler: (child: Instance, maid: Maid) -> void): Connection
	streamable:Destroy()

--]]


local Maid = require(script.Parent.Maid)
local Signal = require(script.Parent.Signal)
local Thread = require(script.Parent.Thread)


local Streamable = {}
Streamable.__index = Streamable


function Streamable.new(parent, childName)

	local self = setmetatable({}, Streamable)

	self._maid = Maid.new()
	self._shown = Signal.new(self._maid)
	self._shownMaid = Maid.new()
	self._maid:GiveTask(self._shownMaid)

	self.Instance = parent:FindFirstChild(childName)

	local function OnInstanceSet()
		local instance = self.Instance
		self._shown:Fire(instance, self._shownMaid)
		self._shownMaid:GiveTask(instance:GetPropertyChangedSignal("Parent"):Connect(function()
			if (not instance.Parent) then
				self._shownMaid:DoCleaning()
			end
		end))
		self._shownMaid:GiveTask(function()
			if (self.Instance == instance) then
				self.Instance = nil
			end
		end)
	end

	local function OnChildAdded(child)
		if (child.Name == childName and not self.Instance) then
			self.Instance = child
			OnInstanceSet()
		end
	end

	self._maid:GiveTask(parent.ChildAdded:Connect(OnChildAdded))
	if (self.Instance) then
		OnInstanceSet()
	end

	return self

end


function Streamable:Observe(handler)
	if (self.Instance) then
		Thread.SpawnNow(handler, self.Instance, self._shownMaid)
	end
	return self._shown:Connect(handler)
end


function Streamable:Destroy()
	self._maid:Destroy()
end


return Streamable
------------------------------------------------------------------------
------------------------------------------------------------------------

function module:GetSwordSkin(Skin)
	local inv = game.ReplicatedStorage.Inventory.Swords
    for i,v in pairs(inv.Common:GetChildren()) do
	if v.Name == Skin then
		return v.Value
	else
		for i,v in pairs(inv.Rare:GetChildren()) do
		if v.Name == Skin then
		    return v.Value
		else
			for i,v in pairs(inv.Epic:GetChildren()) do
			if v.Name == Skin then
		        return v.Value
			else
				for i,v in pairs(inv.Legendary:GetChildren()) do
				if v.Name == Skin then
		            return v.Value
				else
				print("Couldn't find the skin info")
				return nil
				end
			end
		end
	end
end
end
end
end
end
--Simply put it inside any model with bricks inside


local prev 
local parts = script.Parent:GetChildren() 

for i = 1,#parts do 
	if (parts[i].className == "Part") or (parts[i].className == "WedgePart") or (parts[i].className == "Seat") or (parts[i].className == "VehicleSeat") or (parts[i].className == "CornerWedgePart") or (parts[i].className == "WedgePart") or (parts[i].className == "UnionOperation") then 
		if (prev ~= nil)then 
			local weld = Instance.new("Weld") 
			weld.Part0 = prev 
			weld.Part1 = parts[i] 
			weld.C0 = prev.CFrame:inverse() 
			weld.C1 = parts[i].CFrame:inverse() 
			weld.Parent = prev 
		end 
		prev = parts[i] 
	end 
end
--[[
	Creates a new copy of the dictionary and sets a value inside it.
]]
function Immutable.Set(dictionary, key, value)
	local new = {}

	for key, value in pairs(dictionary) do
		new[key] = value
	end

	new[key] = value

	return new
end
------------------------------------------------------------------------
-- handle locals, globals and upvalues and related processing
-- * search mechanism is recursive, calls itself to search parents
-- * used only in singlevar()
------------------------------------------------------------------------
function luaY:singlevaraux(fs, n, var, base)
  if fs == nil then  -- no more levels?
    self:init_exp(var, "VGLOBAL", luaP.NO_REG)  -- default is global variable
    return "VGLOBAL"
  else
    local v = self:searchvar(fs, n)  -- look up at current level
    if v >= 0 then
      self:init_exp(var, "VLOCAL", v)
      if base == 0 then
        self:markupval(fs, v)  -- local will be used as an upval
      end
      return "VLOCAL"
    else  -- not found at current level; try upper one
      if self:singlevaraux(fs.prev, n, var, 0) == "VGLOBAL" then
        return "VGLOBAL"
      end
      var.info = self:indexupvalue(fs, n, var)  -- else was LOCAL or UPVAL
      var.k = "VUPVAL"  -- upvalue in this level
      return "VUPVAL"
    end--if v
  end--if fs
end
--[=[
	Provides a data storage facility with an ability to get sub-stores. So you can write
	directly to this store, overwriting all children, or you can have more partial control
	at children level. This minimizes accidently overwriting.
	The big cost here is that we may leave keys that can't be removed.

	@server
	@class DataStoreStage
]=]

local require = require(script.Parent.loader).load(script)

local BaseObject = require("BaseObject")
local DataStoreDeleteToken = require("DataStoreDeleteToken")
local DataStoreWriter = require("DataStoreWriter")
local Promise = require("Promise")
local PromiseUtils = require("PromiseUtils")
local Signal = require("Signal")
local Table = require("Table")

local DataStoreStage = setmetatable({}, BaseObject)
DataStoreStage.ClassName = "DataStoreStage"
DataStoreStage.__index = DataStoreStage
-- @Context Client
-- Returns the character state script for your local client
function APICharacterState.GetCharacterState()
	return localCharacterState
end