• Version 1.0.736
  • Published
  • 3.35 MB
  • No dependencies
  • MIT license


npm i @rbxts/types
yarn add @rbxts/types
pnpm add @rbxts/types


TypeScript typings for the Roblox platform. Partially handwritten and partially automatically generated.



variable Axes

const Axes: AxesConstructor;

    variable BrickColor

    const BrickColor: BrickColorConstructor;

      variable CatalogSearchParams

      const CatalogSearchParams: CatalogSearchParamsConstructor;

        variable CFrame

        const CFrame: CFrameConstructor;

          variable Color3

          const Color3: Color3Constructor;

            variable ColorSequence

            const ColorSequence: ColorSequenceConstructor;

              variable ColorSequenceKeypoint

              const ColorSequenceKeypoint: ColorSequenceKeypointConstructor;

                variable DateTime

                const DateTime: DateTimeConstructor;

                  variable DockWidgetPluginGuiInfo

                  const DockWidgetPluginGuiInfo: DockWidgetPluginGuiInfoConstructor;

                    variable Faces

                    const Faces: FacesConstructor;

                      variable FloatCurveKey

                      const FloatCurveKey: FloatCurveKeyConstructor;

                        variable Font

                        const Font: FontConstructor;

                          variable game

                          const game: DataModel;

                            variable Instance

                            const Instance: InstanceConstructor;

                              variable NumberRange

                              const NumberRange: NumberRangeConstructor;

                                variable NumberSequence

                                const NumberSequence: NumberSequenceConstructor;

                                  variable NumberSequenceKeypoint

                                  const NumberSequenceKeypoint: NumberSequenceKeypointConstructor;

                                    variable OverlapParams

                                    const OverlapParams: OverlapParamsConstructor;

                                      variable PathWaypoint

                                      const PathWaypoint: PathWaypointConstructor;

                                        variable PhysicalProperties

                                        const PhysicalProperties: PhysicalPropertiesConstructor;

                                          variable Random

                                          const Random: RandomConstructor;

                                            variable Ray

                                            const Ray: RayConstructor;

                                              variable RaycastParams

                                              const RaycastParams: RaycastParamsConstructor;

                                                variable Rect

                                                const Rect: RectConstructor;

                                                  variable Region3

                                                  const Region3: Region3Constructor;

                                                    variable Region3int16

                                                    const Region3int16: Region3int16Constructor;

                                                      variable RotationCurveKey

                                                      const RotationCurveKey: RotationCurveKeyConstructor;

                                                        variable script

                                                        const script: LuaSourceContainer;

                                                          variable shared

                                                          const shared: {};

                                                            variable SharedTable

                                                            const SharedTable: SharedTableConstructor;

                                                              variable SharedTableNominal

                                                              const SharedTableNominal: {};

                                                                variable TweenInfo

                                                                const TweenInfo: TweenInfoConstructor;

                                                                  variable UDim

                                                                  const UDim: UDimConstructor;

                                                                    variable UDim2

                                                                    const UDim2: UDim2Constructor;

                                                                      variable Vector2

                                                                      const Vector2: Vector2Constructor;

                                                                        variable Vector2int16

                                                                        const Vector2int16: Vector2int16Constructor;

                                                                          variable Vector3

                                                                          const Vector3: Vector3Constructor;

                                                                            variable Vector3int16

                                                                            const Vector3int16: Vector3int16Constructor;


                                                                              function delay

                                                                              delay: (delayTime: number, callback: DelayedCallback) => void;
                                                                              • Schedules a function to be executed after delayTime seconds have passed, without yielding the current thread. This function allows multiple Lua threads to be executed in parallel from the same stack. The delay will have a minimum duration of 29 milliseconds, but this minimum may be higher depending on the target framerate and various throttling conditions. If the delayTime parameter is not specified, the minimum duration will be used.

                                                                              function elapsedTime

                                                                              elapsedTime: () => number;
                                                                              • Returns how much time has elapsed since the current instance of Roblox was started. In Roblox Studio, this begins counting up from the moment Roblox Studio starts running, not just when opening a place.


                                                                                use os.clock() instead.

                                                                              function gcinfo

                                                                              gcinfo: () => number;
                                                                              • Returns the total memory heap size in kilobytes. The number reflects the current heap consumption from the operating system perspective, which fluctuates over time as garbage collector frees objects.

                                                                              function require

                                                                              require: (moduleScript: ModuleScript | number) => unknown;
                                                                              • Runs the supplied ModuleScript if it has not been run already, and returns what the ModuleScript returned (in both cases).

                                                                                If the ModuleScript the user wants to use has been uploaded to Roblox (with the instance’s name being ‘MainModule’), it can be loaded by using the require function on the asset ID of the ModuleScript, though only on the server.

                                                                              function spawn

                                                                              spawn: (callback: DelayedCallback) => void;
                                                                              • Runs the specified callback function in a separate thread, without yielding the current thread. The function will be executed the next time Roblox’s Task Scheduler runs an update cycle. This delay will take at least 29 milliseconds but can arbitrarily take longer, depending on the target framerate and various throttling conditions.

                                                                              function tick

                                                                              tick: () => number;

                                                                                function time

                                                                                time: () => number;
                                                                                • Time since the game started running. Will be 0 in Studio when not running the game.

                                                                                function type

                                                                                type: (value: unknown) => keyof CheckablePrimitives;
                                                                                • Returns the type of its only argument, coded as a string. Roblox datatypes will return "userdata" when passed to this function. You should use Roblox's typeOf() function if you want to differentiate between Roblox datatypes.

                                                                                function UserSettings

                                                                                UserSettings: () => UserSettings;

                                                                                  function version

                                                                                  version: () => string;
                                                                                  • Returns the current version of Roblox as a string. The integers in the version string are separated by periods, and each integers represent the following, in order:

                                                                                    Generation - The current generation of the application shell that is hosting the client. Version - The current release version of Roblox. Patch - The current patch number for this version of Roblox. Commit - The ID of the last internal commit that was accepted into this version of the client.

                                                                                  function wait

                                                                                  wait: (seconds?: number) => LuaTuple<[number, number]>;
                                                                                  • Yields the current thread until the specified amount of seconds have elapsed. The delay will have a minimum duration of 29 milliseconds, but this minimum may be higher depending on the target framerate and various throttling conditions. If the seconds parameter is not specified, the minimum duration will be used. This function returns:

                                                                                    Actual time yielded (in seconds) Total time since the software was initialized (in seconds)

                                                                                  function warn

                                                                                  warn: (...params: Array<unknown>) => void;
                                                                                  • Behaves identically to Lua’s print function, except the output is styled as a warning, with yellow text and a timestamp. This function accepts any number of arguments, and will attempt to convert them into strings which will then be joined together with spaces between them.


                                                                                  namespace math

                                                                                  namespace math {}

                                                                                    function clamp

                                                                                    clamp: (n: number, min: number, max: number) => number;
                                                                                    • Returns a number between min and max, inclusive.

                                                                                    function noise

                                                                                    noise: (x: number, y?: number, z?: number) => number;
                                                                                    • Returns a perlin noise value. The returned value is most often between the range [-1, 1].

                                                                                      The returned value is sometimes will be outside of the range [-1,1], so if the interval is critical to you, you should use math.clamp(noise, -1, 1) on the output.

                                                                                      The function uses a perlin noise algorithm to assign fixed values to coordinates. For example, math.noise(1.158, 5.723) will always return 0.48397532105446 and math.noise(1.158, 6) will always return 0.15315161645412.

                                                                                      If x, y and z are all integers, the return value will be 0. For fractional values of x, y and z, the return value will gradually fluctuate between -0.5 and 0.5. For coordinates that are close to each other, the return values will also be close to each other.

                                                                                    namespace task

                                                                                    namespace task {}

                                                                                      function cancel

                                                                                      cancel: (thread: thread) => void;
                                                                                      • Cancels a thread, preventing it from being resumed.

                                                                                      function defer

                                                                                      defer: {
                                                                                      <T extends Array<any>>(callback: (...args: T) => void, ...args: T): thread;
                                                                                      (thread: thread, ...args: Array<unknown>): thread;
                                                                                      • Defers the passed thread or function to be resumed at the end of the current resumption cycle.

                                                                                      function delay

                                                                                      delay: {
                                                                                      <T extends Array<any>>(
                                                                                      duration: number,
                                                                                      callback: (...args: T) => void,
                                                                                      ...args: T
                                                                                      ): thread;
                                                                                      (duration: number, thread: thread, ...args: Array<unknown>): thread;
                                                                                      • Delays the passed thread or function until the given duration has elapsed. Resumes on engine Heartbeat.

                                                                                      function desynchronize

                                                                                      desynchronize: () => void;
                                                                                      • Queues the calling script to be run during the parallel execution phase of the frame.

                                                                                      function spawn

                                                                                      spawn: {
                                                                                      <T extends Array<any>>(callback: (...args: T) => void, ...args: T): thread;
                                                                                      (thread: thread, ...args: Array<unknown>): thread;
                                                                                      • Resumes the passed thread or function instantly using the engine's scheduler.

                                                                                      function synchronize

                                                                                      synchronize: () => void;
                                                                                      • Yields the calling script and queues it for serial execution following the completion of the parallel execution phase of the frame.

                                                                                      function wait

                                                                                      wait: (duration?: number) => number;
                                                                                      • Delay the current thread until the given duration has elasped. Resumes on engine Heartbeat.

                                                                                      namespace utf8

                                                                                      namespace utf8 {}

                                                                                        variable charpattern

                                                                                        const charpattern: string;
                                                                                        • The pattern which matches exactly one UTF-8 byte sequence, assuming that the subject is a valid UTF-8 string.

                                                                                        function char

                                                                                        char: (...codepoints: Array<number>) => string;
                                                                                        • Receives zero or more codepoints as integers, converts each one to its corresponding UTF-8 byte sequence and returns a string with the concatenation of all these sequences.

                                                                                        function codepoint

                                                                                        codepoint: (str: string, i?: number, j?: number) => LuaTuple<Array<number>>;
                                                                                        • Returns the codepoints (as integers) from all codepoints in the provided string (str) that start between byte positions i and j (both included). The default for i is 0 and for j is i. It raises an error if it meets any invalid byte sequence. Similar to string.byte.

                                                                                        function codes

                                                                                        codes: (str: string) => IterableFunction<LuaTuple<[number, number]>>;
                                                                                        • Returns an iterator function that will iterate over all codepoints in string str. It raises an error if it meets any invalid byte sequence.

                                                                                        function graphemes

                                                                                        graphemes: (
                                                                                        s: string,
                                                                                        i?: number,
                                                                                        j?: number
                                                                                        ) => IterableFunction<LuaTuple<[number, number]>>;
                                                                                        • Returns an iterator function that will iterate the grapheme clusters of the string.

                                                                                        function len

                                                                                        len: (
                                                                                        s: string,
                                                                                        i?: number,
                                                                                        j?: number
                                                                                        ) => LuaTuple<[number, undefined] | [false, number]>;
                                                                                        • Returns the number of UTF-8 codepoints in the string str that start between positions i and j (both inclusive). The default for i is 0 and for j is -1. If it finds any invalid byte sequence, returns a false value plus the position of the first invalid byte.

                                                                                        function nfcnormalize

                                                                                        nfcnormalize: (str: string) => string;
                                                                                        • Converts the input string to Normal Form C, which tries to convert decomposed characters into composed characters.

                                                                                        function nfdnormalize

                                                                                        nfdnormalize: (str: string) => string;
                                                                                        • Converts the input string to Normal Form D, which tries to break up composed characters into decomposed characters.

                                                                                        function offset

                                                                                        offset: (s: string, n: number, i?: number) => number | undefined;
                                                                                        • Returns the position (in bytes) where the encoding of the n-th codepoint of s (counting from byte position i) starts. A negative n gets characters before position i. The default for i is 0 when n is non-negative and #s + 1 otherwise, so that utf8.offset(s, -n) gets the offset of the n-th character from the end of the string. If the specified character is neither in the subject nor right after its end, the function returns nil.

                                                                                        Package Files (1)

                                                                                        Dependencies (0)

                                                                                        No dependencies.

                                                                                        Dev Dependencies (0)

                                                                                        No dev dependencies.

                                                                                        Peer Dependencies (0)

                                                                                        No peer dependencies.


                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@rbxts/types.

                                                                                        • Markdown
                                                                                        • HTML
                                                                                          <a href="https://www.jsdocs.io/package/@rbxts/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>