Deno APIs reference

Bundle Typescript/Javascript code

A message emitted from the bundler.

The location of a message.

An output file in the bundle.

The output format of the bundle.

The target platform of the bundle.

The source map type of the bundle.

An operation on a Deno.Kv that can be performed atomically. Atomic operations do not auto-commit, and must be committed explicitly by calling the commit method.

A key-value database that can be used to store and retrieve data.

An iterator over a range of data entries in a Deno.Kv.

Wrapper type for 64-bit unsigned integers for use as values in a Deno.Kv.

Create a cron job that will periodically execute the provided handler callback based on the specified schedule.

Open a new Deno.Kv connection to persist data.

A check to perform as part of a Deno.AtomicOperation. The check will fail if the versionstamp for the key-value pair in the KV store does not match the given versionstamp. A check with a null versionstamp checks that the key-value pair does not currently exist in the KV store.

CronSchedule is the interface used for JSON format cron schedule.

A versioned pair of key and value in a Deno.Kv.

Options for listing key-value pairs in a Deno.Kv.

CronScheduleExpression is used as the type of minute, hour, dayOfMonth, month, and dayOfWeek in CronSchedule.

Consistency level of a KV operation.

An optional versioned pair of key and value in a Deno.Kv.

A key to be persisted in a Deno.Kv. A key is a sequence of Deno.KvKeyParts.

A single part of a Deno.KvKey. Parts are ordered lexicographically, first by their type, and within a given type by their value.

A selector that selects the range of data returned by a list operation on a Deno.Kv.

A mutation to a key in a Deno.Kv. A mutation is a combination of a key, a value, and a type. The type determines how the mutation is applied to the key.

Raised when attempting to open a server listener on an address and port that already has a listener.

Raised when the underlying operating system reports an EADDRNOTAVAIL error.

Raised when trying to create a resource, like a file, that already exits.

The underlying IO resource is invalid or closed, and so the operation could not be performed.

Raised when trying to write to a resource and a broken pipe error occurs. This can happen when trying to write directly to stdout or stderr and the operating system is unable to pipe the output for a reason external to the Deno runtime.

Raised when the underlying IO resource is not available because it is being awaited on in another block of code.

Raised when the underlying operating system reports an ECONNABORTED error.

Raised when the underlying operating system reports that a connection to a resource is refused.

Raised when the underlying operating system reports that a connection has been reset. With network servers, it can be a normal occurrence where a client will abort a connection instead of properly shutting it down.

Raised when too many symbolic links were encountered when resolving the filename.

Raised in situations where when attempting to load a dynamic import, too many redirects were encountered.

Raised when the underlying operating system reports an EINTR error. In many cases, this underlying IO error will be handled internally within Deno, or result in an BadResource error instead.

Raised when an operation returns data that is invalid for the operation being performed.

Raised when trying to open, create or write to a directory.

Raised when performing a socket operation but the remote host is not reachable.

Raised when trying to perform an operation on a path that is not a directory, when directory is required.

Raised when trying to perform an operation while the relevant Deno permission (like --allow-read) has not been granted.

Raised when the underlying operating system reports an ENOTCONN error.

Raised when the underlying operating system indicates that the file was not found.

Raised when the underlying Deno API is asked to perform a function that is not currently supported.

Raised when the underlying operating system indicates the current user which the Deno process is running under does not have the appropriate permissions to a file or resource.

Raised when the underlying operating system reports that an I/O operation has timed out (ETIMEDOUT).

Raised when attempting to read bytes from a resource, but the EOF was unexpectedly encountered.

Raised when the underlying operating system would need to block to complete but an asynchronous (non-blocking) API is used.

Raised when expecting to write to a IO buffer resulted in zero bytes being written.

A set of error constructors that are raised by Deno APIs.

A custom HttpClient for use with fetch function. This is designed to allow custom certificates or proxies to be used with fetch().

Create a custom HttpClient to use with fetch. This is an extension of the web platform Fetch API which allows Deno to use custom TLS CA certificates and connect via a proxy while using fetch().

Basic authentication credentials to be used with a Deno.Proxy server when specifying Deno.CreateHttpClientOptions.

The options used when creating a Deno.HttpClient.

The definition for alternative transports (or proxies) in Deno.CreateHttpClientOptions.

An unsafe function pointer for passing JavaScript functions as C function pointers to foreign function calls.

An unsafe pointer to a function, for calling functions that are not present as symbols.

A collection of static functions for interacting with pointer objects.

An unsafe pointer view to a memory location as specified by the pointer value. The UnsafePointerView API follows the standard built in interface DataView for accessing the underlying types at an memory location (numbers, strings and raw bytes).

Opens an external dynamic library and registers symbols, making foreign functions available to be called.

A dynamic library resource. Use Deno.dlopen to load a dynamic library and return this interface.

The interface for a foreign function as defined by its parameter and result types.

A foreign library interface descriptor.

The native struct type for interfacing with foreign functions.

A non-null pointer, represented as an object at runtime. The object's prototype is null and cannot be changed. The object cannot be assigned to either and is thus entirely read-only.

Definition of a unsafe callback function.

Type conversion for foreign symbol return types.

Type conversion for foreign symbol return types and unsafe callback parameters.

All BigInt number types for interfacing with foreign functions.

The native boolean type for interfacing to foreign functions.

The native buffer type for interfacing to foreign functions.

The native function type for interfacing with foreign functions.

All plain number types for interfacing with foreign functions.

The native pointer type for interfacing to foreign functions.

All supported types for interfacing with foreign functions.

The native void type for interfacing with foreign functions.

Pointers are represented either with a PointerObject object or a null if the pointer is null.

A utility type that infers a foreign library interface.

A utility type that infers a foreign symbol.

A utility type for conversion of parameter types of foreign functions.

Type conversion for unsafe callback return types.

Type conversion for foreign symbol parameters and unsafe callback return types.

An unsafe callback function.

The Deno abstraction for reading and writing files.

Changes the permission of a specific file/directory of specified path. Ignores the process's umask.

Synchronously changes the permission of a specific file/directory of specified path. Ignores the process's umask.

Change owner of a regular file or directory.

Synchronously change owner of a regular file or directory.

Copies the contents and permissions of one file to another specified path, by default creating a new file if needed, else overwriting. Fails if target path is a directory or is unwritable.

Synchronously copies the contents and permissions of one file to another specified path, by default creating a new file if needed, else overwriting. Fails if target path is a directory or is unwritable.

Creates a file if none exists or truncates an existing file and resolves to an instance of Deno.FsFile.

Creates a file if none exists or truncates an existing file and returns an instance of Deno.FsFile.

Creates newpath as a hard link to oldpath.

Synchronously creates newpath as a hard link to oldpath.

Resolves to a Deno.FileInfo for the specified path. If path is a symlink, information for the symlink will be returned instead of what it points to.

Synchronously returns a Deno.FileInfo for the specified path. If path is a symlink, information for the symlink will be returned instead of what it points to.

Creates a new temporary directory in the default directory for temporary files, unless dir is specified. Other optional options include prefixing and suffixing the directory name with prefix and suffix respectively.

Synchronously creates a new temporary directory in the default directory for temporary files, unless dir is specified. Other optional options include prefixing and suffixing the directory name with prefix and suffix respectively.

Creates a new temporary file in the default directory for temporary files, unless dir is specified.

Synchronously creates a new temporary file in the default directory for temporary files, unless dir is specified.

Creates a new directory with the specified path.

Synchronously creates a new directory with the specified path.

Open a file and resolve to an instance of Deno.FsFile. The file does not need to previously exist if using the create or createNew open options. The caller may have the resulting file automatically closed by the runtime once it's out of scope by declaring the file variable with the using keyword.

Synchronously open a file and return an instance of Deno.FsFile. The file does not need to previously exist if using the create or createNew open options. The caller may have the resulting file automatically closed by the runtime once it's out of scope by declaring the file variable with the using keyword.

Reads the directory given by path and returns an async iterable of Deno.DirEntry. The order of entries is not guaranteed.

Synchronously reads the directory given by path and returns an iterable of Deno.DirEntry. The order of entries is not guaranteed.

Reads and resolves to the entire contents of a file as an array of bytes. TextDecoder can be used to transform the bytes to string if required. Rejects with an error when reading a directory.

Synchronously reads and returns the entire contents of a file as an array of bytes. TextDecoder can be used to transform the bytes to string if required. Throws an error when reading a directory.

Resolves to the full path destination of the named symbolic link.

Synchronously returns the full path destination of the named symbolic link.

Asynchronously reads and returns the entire contents of a file as an UTF-8 decoded string. Reading a directory throws an error.

Synchronously reads and returns the entire contents of a file as an UTF-8 decoded string. Reading a directory throws an error.

Resolves to the absolute normalized path, with symbolic links resolved.

Synchronously returns absolute normalized path, with symbolic links resolved.

Removes the named file or directory.

Synchronously removes the named file or directory.

Renames (moves) oldpath to newpath. Paths may be files or directories. If newpath already exists and is not a directory, rename() replaces it. OS-specific restrictions may apply when oldpath and newpath are in different directories.

Synchronously renames (moves) oldpath to newpath. Paths may be files or directories. If newpath already exists and is not a directory, renameSync() replaces it. OS-specific restrictions may apply when oldpath and newpath are in different directories.

Resolves to a Deno.FileInfo for the specified path. Will always follow symlinks.

Synchronously returns a Deno.FileInfo for the specified path. Will always follow symlinks.

Creates newpath as a symbolic link to oldpath.

Creates newpath as a symbolic link to oldpath.

Truncates (or extends) the specified file, to reach the specified len. If len is not specified then the entire file contents are truncated.

Synchronously truncates (or extends) the specified file, to reach the specified len. If len is not specified then the entire file contents are truncated.

Retrieve the process umask. If mask is provided, sets the process umask. This call always returns what the umask was before the call.

Changes the access (atime) and modification (mtime) times of a file system object referenced by path. Given times are either in seconds (UNIX epoch time) or as Date objects.

Synchronously changes the access (atime) and modification (mtime) times of a file system object referenced by path. Given times are either in seconds (UNIX epoch time) or as Date objects.

Watch for file system events against one or more paths, which can be files or directories. These paths must exist already. One user action (e.g. touch test.file) can generate multiple file system events. Likewise, one user action can result in multiple file paths in one event (e.g. mv old_name.txt new_name.txt).

Write data to the given path, by default creating a new file if needed, else overwriting.

Synchronously write data to the given path, by default creating a new file if needed, else overwriting.

Write string data to the given path, by default creating a new file if needed, else overwriting.

Synchronously write string data to the given path, by default creating a new file if needed, else overwriting.

Information about a directory entry returned from Deno.readDir and Deno.readDirSync.

Provides information about a file and is returned by Deno.stat, Deno.lstat, Deno.statSync, and Deno.lstatSync or from calling stat() and statSync() on an Deno.FsFile instance.

Represents a unique file system event yielded by a Deno.FsWatcher.

Returned by Deno.watchFs. It is an async iterator yielding up system events. To stop watching the file system by calling .close() method.

Options which can be set when using Deno.mkdir and Deno.mkdirSync.

Options which can be set when doing Deno.open and Deno.openSync.

Options which can be set when using Deno.readFile or Deno.readFileSync.

Options which can be set when using Deno.remove and Deno.removeSync.

Options that can be used with symlink and symlinkSync.

Options for writing to a file.

Additional information for FsEvent objects with the "other" kind.

Creates a presentable WebGPU surface from given window and display handles.

The webgpu namespace provides additional APIs that the WebGPU specification does not specify.

Serves HTTP requests with the given handler.

An instance of the server created using Deno.serve() API.

Interface that module run with deno serve subcommand must conform to.

Additional information for an HTTP request and its connection.

Options which can be set when calling Deno.serve.

Options that can be passed to Deno.serve to create a server listening on a TCP port.

Options that can be passed to Deno.serve to create a server listening on a Unix domain socket.

Options that can be passed to Deno.serve to create a server listening on a VSOCK socket.

A handler for HTTP requests. Consumes a request and returns a response.

A enum which defines the seek mode for IO related APIs that support seeking.

Gets the size of the console as columns/rows.

Converts the input into a string that has the same format as printed by console.log().

Option which can be specified when performing Deno.inspect.

A reference to stderr which can be used to write directly to stderr. It implements the Deno specific Writer, WriterSync, and Closer interfaces as well as provides a WritableStream interface.

A reference to stdin which can be used to read directly from stdin.

A reference to stdout which can be used to write directly to stdout. It implements the Deno specific Writer, WriterSync, and Closer interfaces as well as provides a WritableStream interface.

Broadcast a message on IO pub channel.

Display function for Jupyter Deno Kernel. Mimics the behavior of IPython's display(obj, raw=True) function to allow asynchronous displaying of objects in Jupyter.

Format an object for displaying in Deno

Show HTML in Jupyter frontends with a tagged template function.

Display a JPG or PNG image.

Show Markdown in Jupyter frontends with a tagged template function.

SVG Tagged Template Function.

A collection of supported media types and data for Jupyter frontends.

A namespace containing runtime APIs available in Jupyter notebooks.

This API is useful for testing lint plugins.

Arrow function expression

Updaate a variable or property.

Assign default values in parameters.

Await a Promise and get its fulfilled value.

Represents numbers that are too high or too low to be represented by the number type.

Compare left and right value with the specifier operator.

A potentially multi-line block comment

Break any loop or labeled statement, example:

The catch clause of a try/catch statement

Represents the body of a class and contains all members

Declares a class in the current scope

Similar to ClassDeclaration but for declaring a class as an expression. The main difference is that the class name(=id) can be omitted.

Terminates the current loop and continues with the next iteration.

Re-run loop for as long as test expression is truthy.

Statement that holds an expression.

Enumerate over all enumerable string properties of an object.

Iterate over sequence of values from an iterator.

Declares a function in the current scope

Declare a function as an expression. Similar to FunctionDeclaration, with an optional name (=id).

Custom named node by the developer. Can be a variable name, a function name, parameter, etc.

Execute a statement the test passes, otherwise the alternate statement, if it was defined.

An import declaration, examples:

Dynamically import a module.

The closing tag of a JSXElement. Only used when the element is not self-closing.

The closing tag of a JSXFragment.

Inserts a normal JS expression into JSX.

Usually a passthrough node to pass multiple sibling elements as the JSX syntax requires one root element.

User named identifier inside JSX.

The opening tag of a JSXElement

The opening tag of a JSXFragment.

Spreads an object as JSX attributes.

Custom control flow based on labels.

Chain expressions based on the operator specified

Can either be import.meta or new.target.

Create a new instance of a class.

In your plugins file do something like

Private members inside of classes, must start with #.

The rest of function parameters.

Returns a value from a function.

Execute multiple expressions in sequence.

Static class initializiation block.

The super keyword used in classes.

A single case of a SwitchStatement.

Match an expression against a series of cases.

Tagged template expression.

The static portion of a template literal.

A template literal string.

The this keyword used in classes.

Throw a user defined exception. Stops execution of the current function.

The body of a TSEnumDeclaration

A member of a TSEnumDeclaration

Body of a TSModuleDeclaration

Apply operand on value based on the specified operator.

Syntactic sugar to increment or decrement a value.

A VariableDeclaration can declare multiple variables. This node represents a single declaration out of that.

Run a loop while the test expression is truthy.

Pause or resume a generator function.

Legacy JavaScript feature, that's discouraged from being used today.

TypeScript accessibility modifiers used in classes

Union type of all possible expression nodes

Union type of all possible child nodes in JSX

Union type of all Literals

Union type of all possible AST nodes

Function/Method parameter

Union type of all possible statement nodes

Union type of all possible type nodes in TypeScript

Connects to the hostname (default is "127.0.0.1") and port on the named transport (default is "tcp"), and resolves to the connection (Conn).

Establishes a secure connection over QUIC using a hostname and port. The cert file is optional and if not included Mozilla's root certificates will be used. See also https://github.com/ctz/webpki-roots for specifics.

Establishes a secure connection over TLS (transport layer security) using an optional list of CA certs, hostname (default is "127.0.0.1") and port.

Listen announces on the local transport address.

Listen announces on the local transport address.

Listen announces on the local transport address over TLS (transport layer security).

Returns an array of the network interface information.

Performs DNS resolution against the given query, returning resolved records.

Start TLS handshake from an existing connection using an optional list of CA certificates, and hostname (default is "127.0.0.1"). Specifying CA certs is optional. By default the configured root certificates are used. Using this function requires that the other end of the connection is prepared for a TLS handshake.

Upgrade a QUIC connection into a WebTransport instance.

If Deno.resolveDns is called with "CAA" record type specified, it will resolve with an array of objects with this interface.

A generic stream-oriented network connection that can be read from and written to.

Options which can be set when connecting via Deno.connect.

Options which can be set when establishing a TLS connection via Deno.connectTls.

A generic transport listener for message-oriented protocols.

A generic network listener for stream-oriented protocols.

Options which can be set when opening a listener via Deno.listen.

Options which can be set when opening a TLS listener via Deno.listenTls.

Represents membership of a IPv4 multicast group.

Represents membership of a IPv6 multicast group.

If Deno.resolveDns is called with "MX" record type specified, it will return an array of objects with this interface.

If Deno.resolveDns is called with "NAPTR" record type specified, it will return an array of objects with this interface.

The address of a network connection or listener using an IP-based transport.

The information for a network interface returned from a call to Deno.networkInterfaces.

An incoming connection for which the server has not yet begun its part of the handshake.

Specialized listener that accepts QUIC connections.

Options which can be set when using Deno.resolveDns.

If Deno.resolveDns is called with "SOA" record type specified, it will return an array of objects with this interface.

If Deno.resolveDns is called with "SRV" record type specified, it will return an array of objects with this interface.

Options which can be set when upgrading an existing connection to TLS via Deno.startTls.

Provides certified key material from strings. The key material is provided in PEM-format (Privacy Enhanced Mail, https://www.rfc-editor.org/rfc/rfc1422) which can be identified by having -----BEGIN----- and -----END----- markers at the beginning and end of the strings. This type of key is not compatible with DER-format keys which are binary.

A TLS-encrypted stream connection over an IP-based transport.

Information about a completed TLS handshake.

Unstable options which can be set when opening a datagram listener via Deno.listenDatagram.

The address of a network connection or listener using a Unix domain socket.

A Unix domain socket stream connection.

Options which can be set when connecting to a Unix domain socket via Deno.connect.

Unstable options which can be set when opening a unixpacket datagram listener via Deno.listenDatagram.

Options which can be set when opening a Unix listener via Deno.listen or Deno.listenDatagram.

The address of a network connection or listener using the VSOCK transport for communication between a virtual machine and its host.

A VSOCK stream connection.

Options which can be set when connecting over VSOCK via Deno.connect.

Options which can be set when opening a VSOCK listener via Deno.listen.

The address of a network connection or listener, regardless of transport.

The type of the resource record to resolve via DNS using Deno.resolveDns.

Specialized listener that accepts TCP connections.

Specialized listener that accepts TLS connections.

Specialized listener that accepts Unix connections.

Specialized listener that accepts VSOCK connections.

Deno's permission management API.

An EventTarget returned from the Deno.permissions API which can provide updates to any state changes of the permission.

The permission descriptor for the allow-env and deny-env permissions, which controls access to being able to read and write to the process environment variables as well as access other information about the environment. The option variable allows scoping the permission to a specific environment variable.

The permission descriptor for the allow-ffi and deny-ffi permissions, which controls access to loading foreign code and interfacing with it via the Foreign Function Interface API available in Deno. The option path allows scoping the permission to a specific path on the host.

The permission descriptor for the allow-import and deny-import permissions, which controls access to importing from remote hosts via the network. The option host allows scoping the permission for outbound connection to a specific host and port.

The permission descriptor for the allow-net and deny-net permissions, which controls access to opening network ports and connecting to remote hosts via the network. The option host allows scoping the permission for outbound connection to a specific host and port.

A set of options which can define the permissions within a test or worker context at a highly specific level.

The interface which defines what event types are supported by PermissionStatus instances.

The permission descriptor for the allow-read and deny-read permissions, which controls access to reading resources from the local host. The option path allows scoping the permission to a specific path (and if the path is a directory any sub paths).

The permission descriptor for the allow-run and deny-run permissions, which controls access to what sub-processes can be executed by Deno. The option command allows scoping the permission to a specific executable.

The permission descriptor for the allow-sys and deny-sys permissions, which controls access to sensitive host system information, which malicious code might attempt to exploit. The option kind allows scoping the permission to a specific piece of information.

The permission descriptor for the allow-write and deny-write permissions, which controls access to writing to resources from the local host. The option path allow scoping the permission to a specific path (and if the path is a directory any sub paths).

Permission descriptors which define a permission and can be queried, requested, or revoked.

The name of a privileged feature which needs permission.

Options which define the permissions within a test or worker context.

The current status of the permission:

Deno's permission management API.

Registers the given function as a listener of the given signal event.

Change the current working directory to the specified path.

Return a string representing the current working directory.

Returns the path to the current deno executable.

Exit the Deno process with optional exit code.

Returns the group id of the process on POSIX platforms. Returns null on windows.

Get the hostname of the machine the Deno process is running on.

Returns an array containing the 1, 5, and 15 minute load averages. The load average is a measure of CPU and IO utilization of the last one, five, and 15 minute periods expressed as a fractional number. Zero means there is no load. On Windows, the three values are always the same and represent the current load, not the 1, 5 and 15 minute load averages.

Returns an object describing the memory usage of the Deno process and the V8 subsystem measured in bytes.

Returns the release version of the Operating System.

Returns the Operating System uptime in number of seconds.

Make the timer of the given id block the event loop from finishing.

Removes the given signal listener that has been registered with Deno.addSignalListener.

Displays the total amount of free and used physical and swap memory in the system, as well as the buffers and caches used by the kernel.

Returns the user id of the process on POSIX platforms. Returns null on Windows.

Make the timer of the given id not block the event loop from finishing.

An interface containing methods to interact with the process environment variables.

Information returned from a call to Deno.systemMemoryInfo.

Operating signals which can be listened for or sent to sub-processes. What signals and what their standard behaviors are OS dependent.

Returns the script arguments to the program.

Information related to the build of the current Deno runtime.

An interface containing methods to interact with the process environment variables.

The exit code for the Deno process.

The URL of the entrypoint module entered from the command-line. It requires read permission to the CWD.

Reflects the NO_COLOR environment variable at program start.

The current process ID of this instance of the Deno CLI.

The process ID of parent process of this instance of the Deno CLI.

Version information related to the current Deno CLI runtime environment.

The interface for handling a child process returned from Deno.Command.spawn.

Send a signal to process under given pid. The value and meaning of the signal to the process is operating system and process dependant. Signal provides the most common signals. Default signal is "SIGTERM".

Spawns a new subprocess, returning a Deno.ChildProcess handle.

Spawns a subprocess, waits for it to finish, and returns the output.

Synchronously spawns a subprocess, waits for it to finish, and returns the output.

Options which can be set when calling Deno.Command.

The interface returned from calling Deno.Command.output or Deno.Command.outputSync which represents the result of spawning the child process.

The interface for stdout and stderr streams for child process returned from Deno.Command.spawn.

APIs for working with the OpenTelemetry observability framework. Deno can export traces, metrics, and logs to OpenTelemetry compatible backends via the OTLP protocol.

Register a benchmark test which will be run when deno bench is used on the command line and the containing module looks like a bench module.

Context that is passed to a benchmarked function. The instance is shared between iterations of the benchmark. Its methods can be used for example to override of the measured portion of the function.

The interface for defining a benchmark test using Deno.bench.

Context that is passed to a testing function, which can be used to either gain information about the current test, or register additional test steps within the current test.

Register a test which will be run when deno test is used on the command line and the containing module looks like a test module.

Upgrade an incoming HTTP request to a WebSocket.

Options which can be set when performing a Deno.upgradeWebSocket upgrade of a Request

The object that is returned from a Deno.upgradeWebSocket request.

The global namespace where Deno specific, non-standard APIs are located.