amber - v1.1.0

amber

Values

add_signal_listener

</> 
pub fn add_signal_listener(
  signal: signal.Signal,
  run handler: fn() -> any,
) -> Nil

args

</> 
pub fn args() -> List(String)

build

</> 
pub fn build() -> build.Build

chdir

</> 
pub fn chdir(directory: String) -> Result(Nil, error.Error)

chmod_sync

</> 
pub fn chmod_sync(
  path: String,
  mode mode: Int,
) -> Result(Nil, error.Error)

chown_sync

</> 
pub fn chown_sync(
  path: String,
  uid uid: option.Option(Int),
  gid gid: option.Option(Int),
) -> Result(Nil, error.Error)

connect

</> 
pub fn connect(
  port: Int,
) -> promise.Promise(Result(tcp_conn.TcpConn, error.Error))

Connects to the hostname (default is “127.0.0.1”) and port on the named transport (default is “tcp”), and resolves to the connection (TcpConn).

connect_tls

</> 
pub fn connect_tls(
  port: Int,
) -> promise.Promise(Result(tls_conn.TlsConn, error.Error))

Establishes a secure connection over TLS (transport layer security).

Uses Mozilla’s root certificates by default (see also https://github.com/ctz/webpki-roots for specifics).

connect_tls_with

</> 
pub fn connect_tls_with(
  port: Int,
  with options: List(connect_tls_option.ConnectTlsOption),
) -> promise.Promise(Result(tls_conn.TlsConn, error.Error))

Establishes a secure connection over TLS with options.

Custom CA certs, hostname, and mutual TLS (mTLS or client certificates) are supported through the options.

connect_with

</> 
pub fn connect_with(
  port: Int,
  with options: List(connect_option.ConnectOption),
) -> promise.Promise(Result(tcp_conn.TcpConn, error.Error))

Connects to the given hostname and port with options.

console_size

</> 
pub fn console_size() -> Result(
  console_size.ConsoleSize,
  error.Error,
)

Gets the size of the console as columns/rows.

This returns the size of the console window as reported by the operating system. It’s not a reflection of how many characters will fit within the console window, but can be used as part of that calculation.

copy_file_sync

</> 
pub fn copy_file_sync(
  from from_path: String,
  to to_path: String,
) -> Result(Nil, error.Error)

create_sync

</> 
pub fn create_sync(
  path: String,
) -> Result(fs_file.FsFile, error.Error)

cwd

</> 
pub fn cwd() -> Result(String, error.Error)

exec_path

</> 
pub fn exec_path() -> Result(String, error.Error)

exit

</> 
pub fn exit() -> Nil

exit_code

</> 
pub fn exit_code() -> Int

exit_with

</> 
pub fn exit_with(code: Int) -> Nil

gid

</> 
pub fn gid() -> Result(option.Option(Int), error.Error)

hostname

</> 
pub fn hostname() -> Result(String, error.Error)

inspect

</> 
pub fn inspect(value: a) -> String

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

inspect_with

</> 
pub fn inspect_with(
  value: a,
  with options: List(inspect_option.InspectOption),
) -> String

is_no_color

</> 
pub fn is_no_color() -> Bool

kill

</> 
pub fn kill(pid: Int) -> Result(Nil, error.Error)

kill_with

</> 
pub fn kill_with(
  pid: Int,
  with signal: signal.Signal,
) -> Result(Nil, error.Error)
</> 
pub fn link_sync(
  from oldpath: String,
  to newpath: String,
) -> Result(Nil, error.Error)

listen

</> 
pub fn listen(
  port: Int,
) -> Result(listener.Listener, error.Error)

Listen announces on the local transport address.

listen_tls

</> 
pub fn listen_tls(
  port: Int,
  certified_key certified_key: tls_certified_key_pem.TlsCertifiedKeyPem,
) -> Result(tls_listener.TlsListener, error.Error)

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

listen_tls_with

</> 
pub fn listen_tls_with(
  port: Int,
  certified_key certified_key: tls_certified_key_pem.TlsCertifiedKeyPem,
  with options: List(listen_tls_option.ListenTlsOption),
) -> Result(tls_listener.TlsListener, error.Error)

Listen announces on the local transport address over TLS with options.

listen_with

</> 
pub fn listen_with(
  port: Int,
  with options: List(listen_option.ListenOption),
) -> Result(listener.Listener, error.Error)

Listen announces on the local transport address with options.

loadavg

</> 
pub fn loadavg() -> Result(#(Float, Float, Float), error.Error)

lstat_sync

</> 
pub fn lstat_sync(
  path: String,
) -> Result(file_info.FileInfo, error.Error)

main_module

</> 
pub fn main_module() -> String

make_temp_dir_sync

</> 
pub fn make_temp_dir_sync() -> Result(String, error.Error)

make_temp_dir_sync_with

</> 
pub fn make_temp_dir_sync_with(
  with options: List(make_temp.MakeTempOption),
) -> Result(String, error.Error)

make_temp_file_sync

</> 
pub fn make_temp_file_sync() -> Result(String, error.Error)

make_temp_file_sync_with

</> 
pub fn make_temp_file_sync_with(
  with options: List(make_temp.MakeTempOption),
) -> Result(String, error.Error)

memory_usage

</> 
pub fn memory_usage() -> memory_usage.MemoryUsage

mkdir_sync

</> 
pub fn mkdir_sync(path: String) -> Result(Nil, error.Error)

mkdir_sync_with

</> 
pub fn mkdir_sync_with(
  path: String,
  with options: List(mkdir.MkdirOption),
) -> Result(Nil, error.Error)

network_interfaces

</> 
pub fn network_interfaces() -> Result(
  List(network_interface_info.NetworkInterfaceInfo),
  error.Error,
)

Returns an array of the network interface information.

open_sync

</> 
pub fn open_sync(
  path: String,
) -> Result(fs_file.FsFile, error.Error)

open_sync_with

</> 
pub fn open_sync_with(
  path: String,
  with options: List(open.OpenOption),
) -> Result(fs_file.FsFile, error.Error)

os_release

</> 
pub fn os_release() -> Result(String, error.Error)

os_uptime

</> 
pub fn os_uptime() -> Result(Int, error.Error)

pid

</> 
pub fn pid() -> Int

ppid

</> 
pub fn ppid() -> Int

read_dir_sync

</> 
pub fn read_dir_sync(
  path: String,
) -> Result(List(dir_entry.DirEntry), error.Error)

read_file_sync

</> 
pub fn read_file_sync(
  path: String,
) -> Result(uint8_array.Uint8Array, error.Error)
</> 
pub fn read_link_sync(
  path: String,
) -> Result(String, error.Error)

read_text_file_sync

</> 
pub fn read_text_file_sync(
  path: String,
) -> Result(String, error.Error)

real_path_sync

</> 
pub fn real_path_sync(
  path: String,
) -> Result(String, error.Error)

ref_timer

</> 
pub fn ref_timer(id: Int) -> Nil

remove_signal_listener

</> 
pub fn remove_signal_listener(
  signal: signal.Signal,
  run handler: fn() -> any,
) -> Nil

remove_sync

</> 
pub fn remove_sync(path: String) -> Result(Nil, error.Error)

remove_sync_with

</> 
pub fn remove_sync_with(
  path: String,
  with options: List(remove.RemoveOption),
) -> Result(Nil, error.Error)

rename_sync

</> 
pub fn rename_sync(
  from oldpath: String,
  to newpath: String,
) -> Result(Nil, error.Error)

resolve_dns

</> 
pub fn resolve_dns(
  query: String,
  record_type record_type: record_type.RecordType,
) -> promise.Promise(Result(List(String), error.Error))

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

resolve_dns_caa

</> 
pub fn resolve_dns_caa(
  query: String,
) -> promise.Promise(
  Result(List(caa_record.CaaRecord), error.Error),
)

Performs DNS resolution for CAA records.

resolve_dns_caa_with

</> 
pub fn resolve_dns_caa_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(
  Result(List(caa_record.CaaRecord), error.Error),
)

resolve_dns_mx

</> 
pub fn resolve_dns_mx(
  query: String,
) -> promise.Promise(
  Result(List(mx_record.MxRecord), error.Error),
)

Performs DNS resolution for MX records.

resolve_dns_mx_with

</> 
pub fn resolve_dns_mx_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(
  Result(List(mx_record.MxRecord), error.Error),
)

resolve_dns_naptr

</> 
pub fn resolve_dns_naptr(
  query: String,
) -> promise.Promise(
  Result(List(naptr_record.NaptrRecord), error.Error),
)

Performs DNS resolution for NAPTR records.

resolve_dns_naptr_with

</> 
pub fn resolve_dns_naptr_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(
  Result(List(naptr_record.NaptrRecord), error.Error),
)

resolve_dns_soa

</> 
pub fn resolve_dns_soa(
  query: String,
) -> promise.Promise(
  Result(List(soa_record.SoaRecord), error.Error),
)

Performs DNS resolution for SOA records.

resolve_dns_soa_with

</> 
pub fn resolve_dns_soa_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(
  Result(List(soa_record.SoaRecord), error.Error),
)

resolve_dns_srv

</> 
pub fn resolve_dns_srv(
  query: String,
) -> promise.Promise(
  Result(List(srv_record.SrvRecord), error.Error),
)

Performs DNS resolution for SRV records.

resolve_dns_srv_with

</> 
pub fn resolve_dns_srv_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(
  Result(List(srv_record.SrvRecord), error.Error),
)

resolve_dns_txt

</> 
pub fn resolve_dns_txt(
  query: String,
) -> promise.Promise(Result(List(List(String)), error.Error))

Performs DNS resolution for TXT records.

resolve_dns_txt_with

</> 
pub fn resolve_dns_txt_with(
  query: String,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(Result(List(List(String)), error.Error))

resolve_dns_with

</> 
pub fn resolve_dns_with(
  query: String,
  record_type record_type: record_type.RecordType,
  with options: List(resolve_dns_option.ResolveDnsOption),
) -> promise.Promise(Result(List(String), error.Error))

set_exit_code

</> 
pub fn set_exit_code(code: Int) -> Nil

set_umask

</> 
pub fn set_umask(mask: Int) -> Int

start_tls

</> 
pub fn start_tls(
  conn: tcp_conn.TcpConn,
) -> promise.Promise(Result(tls_conn.TlsConn, error.Error))

Start TLS handshake from an existing connection using the configured root certificates. Using this function requires that the other end of the connection is prepared for a TLS handshake.

Note that this function consumes the TCP connection passed to it, thus the original TCP connection will be unusable after calling this. Additionally, you need to ensure that the TCP connection is not being used elsewhere when calling this function in order for the TCP connection to be consumed properly. For instance, if there is a Promise that is waiting for read operation on the TCP connection to complete, it is considered that the TCP connection is being used elsewhere. In such a case, this function will fail.

start_tls_with

</> 
pub fn start_tls_with(
  conn: tcp_conn.TcpConn,
  with options: List(start_tls_option.StartTlsOption),
) -> promise.Promise(Result(tls_conn.TlsConn, error.Error))

Start TLS handshake from an existing connection with options.

stat_sync

</> 
pub fn stat_sync(
  path: String,
) -> Result(file_info.FileInfo, error.Error)
</> 
pub fn symlink_sync(
  from oldpath: String,
  to newpath: String,
) -> Result(Nil, error.Error)
</> 
pub fn symlink_sync_with(
  from oldpath: String,
  to newpath: String,
  with options: List(symlink.SymlinkOption),
) -> Result(Nil, error.Error)

system_memory_info

</> 
pub fn system_memory_info() -> Result(
  system_memory_info.SystemMemoryInfo,
  error.Error,
)

truncate_sync

</> 
pub fn truncate_sync(name: String) -> Result(Nil, error.Error)

truncate_to_length_sync

</> 
pub fn truncate_to_length_sync(
  name: String,
  to len: Int,
) -> Result(Nil, error.Error)

uid

</> 
pub fn uid() -> Result(option.Option(Int), error.Error)

umask

</> 
pub fn umask() -> Int

unref_timer

</> 
pub fn unref_timer(id: Int) -> Nil

upgrade_web_socket

</> 
pub fn upgrade_web_socket(
  request: request.Request,
) -> Result(web_socket_upgrade.WebSocketUpgrade, error.Error)

Upgrade an incoming HTTP request to a WebSocket.

Given a Request, returns a WebSocketUpgrade containing a WebSocket and Response. The original request must be responded to with the returned response for the upgrade to be successful.

upgrade_web_socket_with

</> 
pub fn upgrade_web_socket_with(
  request: request.Request,
  with options: List(
    upgrade_web_socket_option.UpgradeWebSocketOption,
  ),
) -> Result(web_socket_upgrade.WebSocketUpgrade, error.Error)

Upgrade an incoming HTTP request to a WebSocket with options.

utime_sync

</> 
pub fn utime_sync(
  path: String,
  atime atime: Int,
  mtime mtime: Int,
) -> Result(Nil, error.Error)

version

</> 
pub fn version() -> version.Version

watch_fs

</> 
pub fn watch_fs(paths: List(String)) -> fs_watcher.FsWatcher

watch_fs_with

</> 
pub fn watch_fs_with(
  paths: List(String),
  with options: List(watch_fs.WatchFsOption),
) -> fs_watcher.FsWatcher

write_file_sync

</> 
pub fn write_file_sync(
  to path: String,
  contents data: uint8_array.Uint8Array,
) -> Result(Nil, error.Error)

write_file_sync_with

</> 
pub fn write_file_sync_with(
  to path: String,
  contents data: uint8_array.Uint8Array,
  with options: List(write_file.WriteFileOption),
) -> Result(Nil, error.Error)

write_text_file_sync

</> 
pub fn write_text_file_sync(
  to path: String,
  contents data: String,
) -> Result(Nil, error.Error)

write_text_file_sync_with

</> 
pub fn write_text_file_sync_with(
  to path: String,
  contents data: String,
  with options: List(write_file.WriteFileOption),
) -> Result(Nil, error.Error)
✨ Search Document