full type definitions for all lute std (#351)

Author: checkraisefold

definitions/crypto.luau

@@ -9,9 +9,18 @@ crypto.hash = {
 	sha512 = {} :: Hash<"sha512">,
 	blake2b256 = {} :: Hash<"blake2b256">,
 }
+crypto.password = {}
 
 function crypto.digest(hash: Hash<any>, message: string | buffer): buffer
 	error("not implemented")
 end
 
+function crypto.password.hash(password: string): buffer
+	error("not implemented")
+end
+
+function crypto.password.verify(hash: buffer, password: string): boolean
+	error("not implemented")
+end
+
 return crypto

definitions/fs.luau

@@ -6,6 +6,7 @@ export type FileHandle = {
 }
 
 export type FileType = "file" | "dir" | "link" | "fifo" | "socket" | "char" | "block" | "unknown"
+export type HandleMode = "r" | "w" | "x" | "a" | "r+" | "w+" | "x+" | "a+"
 
 export type DirectoryEntry = {
 	name: string,
@@ -21,7 +22,7 @@ export type WatchEvent = {
 	rename: boolean,
 }
 
-function fs.open(path: string): FileHandle
+function fs.open(path: string, mode: HandleMode?): FileHandle
 	error("not implemented")
 end
 

definitions/net.luau

@@ -1,33 +1,47 @@
 local net = {}
 
-export type metadata = {
+export type Metadata = {
 	method: string?,
 	body: string?,
 	headers: { [string]: string }?,
 }
 
-export type request = {
+export type Request = {
 	body: string,
 	headers: { [string]: string },
 	status: number,
 	ok: boolean,
 }
 
-function net.request(url: string, metadata: metadata?): request
+function net.request(url: string, metadata: Metadata?): Request
 	error("not implemented")
 end
 
-export type handler = (...any) -> ...any
+export type ReceivedRequest = {
+	method: string,
+	path: string,
+	body: string,
+	query: { [string]: string },
+	headers: { [string]: string },
+}
+
+export type ServerResponse = string | {
+	status: number?,
+	body: string?,
+	headers: { [string]: string }?,
+}
+
+export type Handler = (request: ReceivedRequest) -> ServerResponse
 
-export type configuration = {
+export type Configuration = {
 	hostname: string?,
 	port: number?,
 	reuseport: boolean?,
-	tls: { cert_file_name: string, key_file_name: string, passphrase: string?, ca_file_name: string? },
-	handler: handler,
+	tls: { cert_file_name: string, key_file_name: string, passphrase: string?, ca_file_name: string? }?,
+	handler: Handler,
 }
 
-function net.serve(config: configuration | handler)
+function net.serve(config: Handler | Configuration)
 	error("not implemented")
 end
 

definitions/process.luau

@@ -0,0 +1,34 @@
+export type StdioKind = "default" | "inherit" | "none" | ""
+
+export type ProcessRunOptions = {
+	shell: (string | boolean)?,
+	cwd: string?,
+	stdio: StdioKind?,
+
+	env: { [string]: string }?,
+}
+
+export type ProcessResult = {
+	stdout: string,
+	stderr: string,
+
+	ok: boolean,
+	exitcode: number,
+	signal: string?,
+}
+
+local process = {}
+
+function process.homedir(): string
+	error("not implemented")
+end
+
+function process.cwd(): string
+	error("not implemented")
+end
+
+function process.run(args: string | { string }, options: ProcessRunOptions?): ProcessResult
+	error("not implemented")
+end
+
+return process

definitions/system.luau

@@ -0,0 +1,43 @@
+export type CpuInfo = {
+	model: string,
+	speed: number,
+
+	times: {
+		sys: number,
+		idle: number,
+		irq: number,
+		nice: number,
+		user: number,
+	},
+}
+
+local system = {}
+
+function system.threadcount(): number
+	error("unimplemented")
+end
+
+function system.hostname(): string
+	error("unimplemented")
+end
+
+function system.totalmemory(): number
+	error("unimplemented")
+end
+
+function system.freememory(): number
+	error("unimplemented")
+end
+
+function system.uptime(): number
+	error("unimplemented")
+end
+
+function system.cpus(): { CpuInfo }
+	error("unimplemented")
+end
+
+system.os = "" :: string
+system.arch = "" :: string
+
+return system

definitions/task.luau

@@ -0,0 +1,21 @@
+local time = require("./time")
+
+local task = {}
+
+function task.defer()
+	error("unimplemented")
+end
+
+function task.wait(dur: (number | time.Duration)?)
+	error("unimplemented")
+end
+
+function task.spawn<T..., U...>(routine: ((T...) -> U...) | thread, ...: T...)
+	error("unimplemented")
+end
+
+function task.resume(thread: thread)
+	error("unimplemented")
+end
+
+return task

definitions/time.luau

@@ -0,0 +1,112 @@
+local time = {}
+local duration = {}
+local duration_ops = {}
+local instant = {}
+
+function time.now(): Instant
+	error("not implemented")
+end
+
+function time.since(instant: Instant): number
+	error("not implemented")
+end
+
+function duration.nanoseconds(nanoseconds: number): Duration
+	error("not implemented")
+end
+
+function duration.microseconds(microseconds: number): Duration
+	error("not implemented")
+end
+
+function duration.milliseconds(milliseconds: number): Duration
+	error("not implemented")
+end
+
+function duration.seconds(seconds: number): Duration
+	error("not implemented")
+end
+
+function duration.minutes(minutes: number): Duration
+	error("not implemented")
+end
+
+function duration.hours(hours: number): Duration
+	error("not implemented")
+end
+
+function duration.days(days: number): Duration
+	error("not implemented")
+end
+
+function duration.weeks(weeks: number): Duration
+	error("not implemented")
+end
+
+function instant.elapsed(self: Instant): number
+	error("not implemented")
+end
+
+function duration_ops.tonanoseconds(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.tomicroseconds(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.tomilliseconds(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.toseconds(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.tominutes(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.tohours(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.todays(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.toweeks(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.subsecnanos(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.subsecmicros(self: Duration): number
+	error("not implemented")
+end
+
+function duration_ops.subsecmillis(self: Duration): number
+	error("not implemented")
+end
+
+type Frozen = typeof(table.freeze({}))
+export type Duration = setmetatable<Frozen, {
+	read __metatable: "The metatable is locked!",
+	read __index: typeof(table.freeze(duration_ops)),
+	read __add: (Duration, Duration) -> Duration,
+	read __sub: (Duration, Duration) -> Duration,
+	read __eq: (Duration, Duration) -> boolean,
+	read __lt: (Duration, Duration) -> boolean,
+	read __le: (Duration, Duration) -> boolean,
+}>
+
+export type Instant = setmetatable<Frozen, {
+	read __metatable: "The metatable is locked!",
+	read __index: typeof(table.freeze(instant)),
+	read __sub: (Instant, Instant) -> Duration,
+}>
+
+time.duration = duration
+return time

definitions/vm.luau

@@ -1,6 +1,6 @@
 local vm = {}
 
-function vm.create(path: string): any
+function vm.create(path: string): { [any]: any }
 	error("not implemented")
 end