@rbxts/types 1.0.571 → 1.0.574

package/include/lua.d.ts

@@ -680,6 +680,15 @@ declare namespace table {
 	 * for tables that are to be re-used.
 	 */
 	function clear(t: object): void;
+	/**
+	 * Creates a table with the array portion allocated to the given number of elements, optionally filled with the given value.
+	 *
+	 * If you are inserting into large array-like tables and are certain of a reasonable upper limit to the number of elements,
+	 * it’s recommended to use this function to initialize the table.
+	 * This ensures the table’s array portion of its memory is sufficiently sized, as resizing it can be expensive.
+	 * For small quantities this is typically not noticeable.
+	 */
+	function create<T>(count: number, value?: T): Array<T>;
 	/**
 	 * Sorts list elements in a given order, in-place, from `list[1]` to `list[#list]`. Comp is a function that
 	 * receives two list elements and returns true when the first element must come before the second in the final order

package/include/roblox.d.ts

@@ -1493,6 +1493,19 @@ type FloatCurveKeyConstructor = new (
 ) => FloatCurveKey;
 declare const FloatCurveKey: FloatCurveKeyConstructor;
 
+// Font
+interface Font {
+	Bold: boolean;
+	Style: Enum.FontStyle;
+	Family: string;
+	Weight: Enum.FontWeight;
+}
+interface FontConstructor {
+	new (family: string, weight?: Enum.FontWeight, style?: Enum.FontStyle): Font;
+	fromEnum: (value: Enum.Font) => Font;
+}
+declare const Font: FontConstructor;
+
 // NumberRange
 interface NumberRange {
 	/**
@@ -2309,46 +2322,3 @@ interface CheckableTypes extends CheckablePrimitives {
 	Vector3: Vector3;
 	Vector3int16: Vector3int16;
 }
-
-/** Returns the type of the given object as a string. This function works similarly to Lua’s native type function, with the exceptions that Roblox-defined data types like Vector3 and CFrame return their respective data types as strings. */
-declare function typeOf(value: unknown): Exclude<keyof CheckableTypes, "vector">;
-
-/**
- * Returns true if `typeof(value) == type`, otherwise false.
- * This function allows for type narrowing. i.e.
-```
-// v is unknown
-if (typeIs(v, "Vector3")) {
-	print(v.X, v.Y, v.Z);
-}
-```
- **/
-declare function typeIs<T extends keyof CheckableTypes>(value: unknown, type: T): value is CheckableTypes[T];
-
-/**
- * Calls the function func with the given arguments in protected mode.
- *
- * opcall is an easier to use version of pcall. It returns a result object instead of multiple returns.
- **/
-declare function opcall<T extends Array<any>, U>(
-	func: (...args: T) => U,
-	...args: T
-): { success: true; value: U } | { success: false; error: string };
-
-/**
- * Returns true if `instance.ClassName == Q`, otherwise false.
- * This function allows for ClassName narrowing. i.e.
- * @example
- * if (classIs(o, "LocalScript")) {
- * // o is a LocalScript
- * }
- * if (classIs(o, "Script")) {
- * // o is a Script & { ClassName: "Script" }
- * // Notice how it specifies the ClassName property here.
- * // This is because a `LocalScript` is-a `Script`, but `o` refers to
- * // an instance for which `ClassName` is "Script"
- * }
- * @param instance
- * @param className
- */
-declare function classIs<T extends keyof Instances>(instance: Instance, className: T): instance is Instances[T];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbxts/types",
-	"version": "1.0.571",
+	"version": "1.0.574",
 	"publishConfig": {
 		"access": "public"
 	},