@bytecodealliance/preview2-shim 0.0.14 → 0.0.16

package/types/interfaces/wasi-io-streams.d.ts

@@ -0,0 +1,274 @@
+export namespace WasiIoStreams {
+  /**
+   * Perform a non-blocking read from the stream.
+   * 
+   * This function returns a list of bytes containing the data that was
+   * read, along with a `stream-status` which, indicates whether further
+   * reads are expected to produce data. The returned list will contain up to
+   * `len` bytes; it may return fewer than requested, but not more. An
+   * empty list and `stream-status:open` indicates no more data is
+   * available at this time, and that the pollable given by
+   * `subscribe-to-input-stream` will be ready when more data is available.
+   * 
+   * Once a stream has reached the end, subsequent calls to `read` or
+   * `skip` will always report `stream-status:ended` rather than producing more
+   * data.
+   * 
+   * When the caller gives a `len` of 0, it represents a request to read 0
+   * bytes. This read should  always succeed and return an empty list and
+   * the current `stream-status`.
+   * 
+   * The `len` parameter is a `u64`, which could represent a list of u8 which
+   * is not possible to allocate in wasm32, or not desirable to allocate as
+   * as a return value by the callee. The callee may return a list of bytes
+   * less than `len` in size while more bytes are available for reading.
+   */
+  export function read(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
+  /**
+   * Read bytes from a stream, after blocking until at least one byte can
+   * be read. Except for blocking, identical to `read`.
+   */
+  export function blockingRead(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
+  /**
+   * Skip bytes from a stream.
+   * 
+   * This is similar to the `read` function, but avoids copying the
+   * bytes into the instance.
+   * 
+   * Once a stream has reached the end, subsequent calls to read or
+   * `skip` will always report end-of-stream rather than producing more
+   * data.
+   * 
+   * This function returns the number of bytes skipped, along with a
+   * `stream-status` indicating whether the end of the stream was
+   * reached. The returned value will be at most `len`; it may be less.
+   */
+  export function skip(this_: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Skip bytes from a stream, after blocking until at least one byte
+   * can be skipped. Except for blocking behavior, identical to `skip`.
+   */
+  export function blockingSkip(this_: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Create a `pollable` which will resolve once either the specified stream
+   * has bytes available to read or the other end of the stream has been
+   * closed.
+   * The created `pollable` is a child resource of the `input-stream`.
+   * Implementations may trap if the `input-stream` is dropped before
+   * all derived `pollable`s created with this function are dropped.
+   */
+  export function subscribeToInputStream(this_: InputStream): Pollable;
+  /**
+   * Dispose of the specified `input-stream`, after which it may no longer
+   * be used.
+   * Implementations may trap if this `input-stream` is dropped while child
+   * `pollable` resources are still alive.
+   * After this `input-stream` is dropped, implementations may report any
+   * corresponding `output-stream` has `stream-state.closed`.
+   */
+  export function dropInputStream(this_: InputStream): void;
+  /**
+   * Check readiness for writing. This function never blocks.
+   * 
+   * Returns the number of bytes permitted for the next call to `write`,
+   * or an error. Calling `write` with more bytes than this function has
+   * permitted will trap.
+   * 
+   * When this function returns 0 bytes, the `subscribe-to-output-stream`
+   * pollable will become ready when this function will report at least
+   * 1 byte, or an error.
+   */
+  export function checkWrite(this_: OutputStream): bigint;
+  /**
+   * Perform a write. This function never blocks.
+   * 
+   * Precondition: check-write gave permit of Ok(n) and contents has a
+   * length of less than or equal to n. Otherwise, this function will trap.
+   * 
+   * returns Err(closed) without writing if the stream has closed since
+   * the last call to check-write provided a permit.
+   */
+  export function write(this_: OutputStream, contents: Uint8Array): void;
+  /**
+   * Perform a write of up to 4096 bytes, and then flush the stream. Block
+   * until all of these operations are complete, or an error occurs.
+   * 
+   * This is a convenience wrapper around the use of `check-write`,
+   * `subscribe-to-output-stream`, `write`, and `flush`, and is implemented
+   * with the following pseudo-code:
+   * 
+   * ```text
+   * let pollable = subscribe-to-output-stream(this);
+   * while !contents.is_empty() {
+     * // Wait for the stream to become writable
+     * poll-oneoff(pollable);
+     * let Ok(n) = check-write(this); // eliding error handling
+     * let len = min(n, contents.len());
+     * let (chunk, rest) = contents.split_at(len);
+     * write(this, chunk);            // eliding error handling
+     * contents = rest;
+     * }
+     * flush(this);
+     * // Wait for completion of `flush`
+     * poll-oneoff(pollable);
+     * // Check for any errors that arose during `flush`
+     * let _ = check-write(this);       // eliding error handling
+     * ```
+     */
+    export function blockingWriteAndFlush(this_: OutputStream, contents: Uint8Array): void;
+    /**
+     * Request to flush buffered output. This function never blocks.
+     * 
+     * This tells the output-stream that the caller intends any buffered
+     * output to be flushed. the output which is expected to be flushed
+     * is all that has been passed to `write` prior to this call.
+     * 
+     * Upon calling this function, the `output-stream` will not accept any
+     * writes (`check-write` will return `ok(0)`) until the flush has
+     * completed. The `subscribe-to-output-stream` pollable will become ready
+     * when the flush has completed and the stream can accept more writes.
+     */
+    export function flush(this_: OutputStream): void;
+    /**
+     * Request to flush buffered output, and block until flush completes
+     * and stream is ready for writing again.
+     */
+    export function blockingFlush(this_: OutputStream): void;
+    /**
+     * Create a `pollable` which will resolve once the output-stream
+     * is ready for more writing, or an error has occured. When this
+     * pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+     * error.
+     * 
+     * If the stream is closed, this pollable is always ready immediately.
+     * 
+     * The created `pollable` is a child resource of the `output-stream`.
+     * Implementations may trap if the `output-stream` is dropped before
+     * all derived `pollable`s created with this function are dropped.
+     */
+    export function subscribeToOutputStream(this_: OutputStream): Pollable;
+    /**
+     * Write zeroes to a stream.
+     * 
+     * this should be used precisely like `write` with the exact same
+     * preconditions (must use check-write first), but instead of
+     * passing a list of bytes, you simply pass the number of zero-bytes
+     * that should be written.
+     */
+    export function writeZeroes(this_: OutputStream, len: bigint): void;
+    /**
+     * Read from one stream and write to another.
+     * 
+     * This function returns the number of bytes transferred; it may be less
+     * than `len`.
+     * 
+     * Unlike other I/O functions, this function blocks until all the data
+     * read from the input stream has been written to the output stream.
+     */
+    export function splice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+    /**
+     * Read from one stream and write to another, with blocking.
+     * 
+     * This is similar to `splice`, except that it blocks until at least
+     * one byte can be read.
+     */
+    export function blockingSplice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+    /**
+     * Forward the entire contents of an input stream to an output stream.
+     * 
+     * This function repeatedly reads from the input stream and writes
+     * the data to the output stream, until the end of the input stream
+     * is reached, or an error is encountered.
+     * 
+     * Unlike other I/O functions, this function blocks until the end
+     * of the input stream is seen and all the data has been written to
+     * the output stream.
+     * 
+     * This function returns the number of bytes transferred, and the status of
+     * the output stream.
+     */
+    export function forward(this_: OutputStream, src: InputStream): [bigint, StreamStatus];
+    /**
+     * Dispose of the specified `output-stream`, after which it may no longer
+     * be used.
+     * Implementations may trap if this `output-stream` is dropped while
+     * child `pollable` resources are still alive.
+     * After this `output-stream` is dropped, implementations may report any
+     * corresponding `input-stream` has `stream-state.closed`.
+     */
+    export function dropOutputStream(this_: OutputStream): void;
+  }
+  import type { Pollable } from '../interfaces/wasi-poll-poll';
+  export { Pollable };
+  /**
+   * Streams provide a sequence of data and then end; once they end, they
+   * no longer provide any further data.
+   * 
+   * For example, a stream reading from a file ends when the stream reaches
+   * the end of the file. For another example, a stream reading from a
+   * socket ends when the socket is closed.
+   * # Variants
+   * 
+   * ## `"open"`
+   * 
+   * The stream is open and may produce further data.
+   * ## `"ended"`
+   * 
+   * When reading, this indicates that the stream will not produce
+   * further data.
+   * When writing, this indicates that the stream will no longer be read.
+   * Further writes are still permitted.
+   */
+  export type StreamStatus = 'open' | 'ended';
+  /**
+   * An input bytestream. In the future, this will be replaced by handle
+   * types.
+   * 
+   * `input-stream`s are *non-blocking* to the extent practical on underlying
+   * platforms. I/O operations always return promptly; if fewer bytes are
+   * promptly available than requested, they return the number of bytes promptly
+   * available, which could even be zero. To wait for data to be available,
+   * use the `subscribe-to-input-stream` function to obtain a `pollable` which
+   * can be polled for using `wasi:poll/poll.poll_oneoff`.
+   * 
+   * And at present, it is a `u32` instead of being an actual handle, until
+   * the wit-bindgen implementation of handles and resources is ready.
+   * 
+   * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+   */
+  export type InputStream = number;
+  /**
+   * An output bytestream. In the future, this will be replaced by handle
+   * types.
+   * 
+   * `output-stream`s are *non-blocking* to the extent practical on
+   * underlying platforms. Except where specified otherwise, I/O operations also
+   * always return promptly, after the number of bytes that can be written
+   * promptly, which could even be zero. To wait for the stream to be ready to
+   * accept data, the `subscribe-to-output-stream` function to obtain a
+   * `pollable` which can be polled for using `wasi:poll`.
+   * 
+   * And at present, it is a `u32` instead of being an actual handle, until
+   * the wit-bindgen implementation of handles and resources is ready.
+   * 
+   * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+   */
+  export type OutputStream = number;
+  /**
+   * An error for output-stream operations.
+   * 
+   * Contrary to input-streams, a closed output-stream is reported using
+   * an error.
+   * # Variants
+   * 
+   * ## `"last-operation-failed"`
+   * 
+   * The last operation (a write or flush) failed before completion.
+   * ## `"closed"`
+   * 
+   * The stream is closed: no more input will be accepted by the
+   * stream. A closed output-stream will return this error on all
+   * future operations.
+   */
+  export type WriteError = 'last-operation-failed' | 'closed';
+  

package/types/{imports → interfaces}/wasi-sockets-instance-network.d.ts

@@ -4,5 +4,5 @@ export namespace WasiSocketsInstanceNetwork {
    */
   export function instanceNetwork(): Network;
 }
-import type { Network } from '../imports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };

package/types/{exports → interfaces}/wasi-sockets-ip-name-lookup.d.ts

@@ -31,7 +31,7 @@ export namespace WasiSocketsIpNameLookup {
    * - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
    * - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
    */
-  export function resolveAddresses(network: Network, name: string, addressFamily: IpAddressFamily | null, includeUnavailable: boolean): ResolveAddressStream;
+  export function resolveAddresses(network: Network, name: string, addressFamily: IpAddressFamily | undefined, includeUnavailable: boolean): ResolveAddressStream;
   /**
    * Returns the next address from the resolver.
    * 
@@ -48,7 +48,7 @@ export namespace WasiSocketsIpNameLookup {
    * - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
    * - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
    */
-  export function resolveNextAddress(this_: ResolveAddressStream): IpAddress | null;
+  export function resolveNextAddress(this_: ResolveAddressStream): IpAddress | undefined;
   /**
    * Dispose of the specified `resolve-address-stream`, after which it may no longer be used.
    * 
@@ -63,14 +63,14 @@ export namespace WasiSocketsIpNameLookup {
    */
   export function subscribe(this_: ResolveAddressStream): Pollable;
 }
-import type { Pollable } from '../exports/wasi-poll-poll';
+import type { Pollable } from '../interfaces/wasi-poll-poll';
 export { Pollable };
-import type { Network } from '../exports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../exports/wasi-sockets-network';
+import type { ErrorCode } from '../interfaces/wasi-sockets-network';
 export { ErrorCode };
-import type { IpAddress } from '../exports/wasi-sockets-network';
+import type { IpAddress } from '../interfaces/wasi-sockets-network';
 export { IpAddress };
-import type { IpAddressFamily } from '../exports/wasi-sockets-network';
+import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
 export type ResolveAddressStream = number;

package/types/{imports → interfaces}/wasi-sockets-tcp-create-socket.d.ts

@@ -23,11 +23,11 @@ export namespace WasiSocketsTcpCreateSocket {
    */
   export function createTcpSocket(addressFamily: IpAddressFamily): TcpSocket;
 }
-import type { Network } from '../imports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../imports/wasi-sockets-network';
+import type { ErrorCode } from '../interfaces/wasi-sockets-network';
 export { ErrorCode };
-import type { IpAddressFamily } from '../imports/wasi-sockets-network';
+import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
-import type { TcpSocket } from '../imports/wasi-sockets-tcp';
+import type { TcpSocket } from '../interfaces/wasi-sockets-tcp';
 export { TcpSocket };

package/types/{imports → interfaces}/wasi-sockets-tcp.d.ts

@@ -63,6 +63,11 @@ export namespace WasiSocketsTcp {
    * - <https://man.freebsd.org/cgi/man.cgi?connect>
    */
   export function startConnect(this_: TcpSocket, network: Network, remoteAddress: IpSocketAddress): void;
+  /**
+   * Note: the returned `input-stream` and `output-stream` are child
+   * resources of the `tcp-socket`. Implementations may trap if the
+   * `tcp-socket` is dropped before both of these streams are dropped.
+   */
   export function finishConnect(this_: TcpSocket): [InputStream, OutputStream];
   /**
    * Start listening for new connections.
@@ -100,6 +105,10 @@ export namespace WasiSocketsTcp {
    * On success, this function returns the newly accepted client socket along with
    * a pair of streams that can be used to read & write to the connection.
    * 
+   * Note: the returned `input-stream` and `output-stream` are child
+   * resources of the returned `tcp-socket`. Implementations may trap if the
+   * `tcp-socket` is dropped before its child streams are dropped.
+   * 
    * # Typical errors
    * - `not-listening`: Socket is not in the Listener state. (EINVAL)
    * - `would-block`:   No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
@@ -216,6 +225,10 @@ export namespace WasiSocketsTcp {
   /**
    * Create a `pollable` which will resolve once the socket is ready for I/O.
    * 
+   * The created `pollable` is a child resource of the `tcp-socket`.
+   * Implementations may trap if the `tcp-socket` is dropped before all
+   * derived `pollable`s created with this function are dropped.
+   * 
    * Note: this function is here for WASI Preview2 only.
    * It's planned to be removed when `future` is natively supported in Preview3.
    */
@@ -251,19 +264,19 @@ export namespace WasiSocketsTcp {
    */
   export function dropTcpSocket(this_: TcpSocket): void;
 }
-import type { InputStream } from '../imports/wasi-io-streams';
+import type { InputStream } from '../interfaces/wasi-io-streams';
 export { InputStream };
-import type { OutputStream } from '../imports/wasi-io-streams';
+import type { OutputStream } from '../interfaces/wasi-io-streams';
 export { OutputStream };
-import type { Pollable } from '../imports/wasi-poll-poll';
+import type { Pollable } from '../interfaces/wasi-poll-poll';
 export { Pollable };
-import type { Network } from '../imports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../imports/wasi-sockets-network';
+import type { ErrorCode } from '../interfaces/wasi-sockets-network';
 export { ErrorCode };
-import type { IpSocketAddress } from '../imports/wasi-sockets-network';
+import type { IpSocketAddress } from '../interfaces/wasi-sockets-network';
 export { IpSocketAddress };
-import type { IpAddressFamily } from '../imports/wasi-sockets-network';
+import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
 /**
  * A TCP socket handle.

package/types/{exports → interfaces}/wasi-sockets-udp-create-socket.d.ts

@@ -23,11 +23,11 @@ export namespace WasiSocketsUdpCreateSocket {
    */
   export function createUdpSocket(addressFamily: IpAddressFamily): UdpSocket;
 }
-import type { Network } from '../exports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../exports/wasi-sockets-network';
+import type { ErrorCode } from '../interfaces/wasi-sockets-network';
 export { ErrorCode };
-import type { IpAddressFamily } from '../exports/wasi-sockets-network';
+import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
-import type { UdpSocket } from '../exports/wasi-sockets-udp';
+import type { UdpSocket } from '../interfaces/wasi-sockets-udp';
 export { UdpSocket };

package/types/{exports → interfaces}/wasi-sockets-udp.d.ts

@@ -208,15 +208,15 @@ export namespace WasiSocketsUdp {
    */
   export function dropUdpSocket(this_: UdpSocket): void;
 }
-import type { Pollable } from '../exports/wasi-poll-poll';
+import type { Pollable } from '../interfaces/wasi-poll-poll';
 export { Pollable };
-import type { Network } from '../exports/wasi-sockets-network';
+import type { Network } from '../interfaces/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../exports/wasi-sockets-network';
+import type { ErrorCode } from '../interfaces/wasi-sockets-network';
 export { ErrorCode };
-import type { IpSocketAddress } from '../exports/wasi-sockets-network';
+import type { IpSocketAddress } from '../interfaces/wasi-sockets-network';
 export { IpSocketAddress };
-import type { IpAddressFamily } from '../exports/wasi-sockets-network';
+import type { IpAddressFamily } from '../interfaces/wasi-sockets-network';
 export { IpAddressFamily };
 /**
  * A UDP socket handle.

package/types/wasi-cli-command.d.ts

@@ -1,29 +1,29 @@
-import { WasiCliEnvironment } from './imports/wasi-cli-environment';
-import { WasiCliExit } from './imports/wasi-cli-exit';
-import { WasiCliStderr } from './imports/wasi-cli-stderr';
-import { WasiCliStdin } from './imports/wasi-cli-stdin';
-import { WasiCliStdout } from './imports/wasi-cli-stdout';
-import { WasiCliTerminalInput } from './imports/wasi-cli-terminal-input';
-import { WasiCliTerminalOutput } from './imports/wasi-cli-terminal-output';
-import { WasiCliTerminalStderr } from './imports/wasi-cli-terminal-stderr';
-import { WasiCliTerminalStdin } from './imports/wasi-cli-terminal-stdin';
-import { WasiCliTerminalStdout } from './imports/wasi-cli-terminal-stdout';
-import { WasiClocksMonotonicClock } from './imports/wasi-clocks-monotonic-clock';
-import { WasiClocksTimezone } from './imports/wasi-clocks-timezone';
-import { WasiClocksWallClock } from './imports/wasi-clocks-wall-clock';
-import { WasiFilesystemPreopens } from './imports/wasi-filesystem-preopens';
-import { WasiFilesystemTypes } from './imports/wasi-filesystem-types';
-import { WasiIoStreams } from './imports/wasi-io-streams';
-import { WasiPollPoll } from './imports/wasi-poll-poll';
-import { WasiRandomInsecure } from './imports/wasi-random-insecure';
-import { WasiRandomInsecureSeed } from './imports/wasi-random-insecure-seed';
-import { WasiRandomRandom } from './imports/wasi-random-random';
-import { WasiSocketsInstanceNetwork } from './imports/wasi-sockets-instance-network';
-import { WasiSocketsIpNameLookup } from './imports/wasi-sockets-ip-name-lookup';
-import { WasiSocketsNetwork } from './imports/wasi-sockets-network';
-import { WasiSocketsTcp } from './imports/wasi-sockets-tcp';
-import { WasiSocketsTcpCreateSocket } from './imports/wasi-sockets-tcp-create-socket';
-import { WasiSocketsUdp } from './imports/wasi-sockets-udp';
-import { WasiSocketsUdpCreateSocket } from './imports/wasi-sockets-udp-create-socket';
-import { WasiCliRun } from './exports/wasi-cli-run';
+import { WasiCliEnvironment } from './interfaces/wasi-cli-environment';
+import { WasiCliExit } from './interfaces/wasi-cli-exit';
+import { WasiCliStderr } from './interfaces/wasi-cli-stderr';
+import { WasiCliStdin } from './interfaces/wasi-cli-stdin';
+import { WasiCliStdout } from './interfaces/wasi-cli-stdout';
+import { WasiCliTerminalInput } from './interfaces/wasi-cli-terminal-input';
+import { WasiCliTerminalOutput } from './interfaces/wasi-cli-terminal-output';
+import { WasiCliTerminalStderr } from './interfaces/wasi-cli-terminal-stderr';
+import { WasiCliTerminalStdin } from './interfaces/wasi-cli-terminal-stdin';
+import { WasiCliTerminalStdout } from './interfaces/wasi-cli-terminal-stdout';
+import { WasiClocksMonotonicClock } from './interfaces/wasi-clocks-monotonic-clock';
+import { WasiClocksTimezone } from './interfaces/wasi-clocks-timezone';
+import { WasiClocksWallClock } from './interfaces/wasi-clocks-wall-clock';
+import { WasiFilesystemPreopens } from './interfaces/wasi-filesystem-preopens';
+import { WasiFilesystemTypes } from './interfaces/wasi-filesystem-types';
+import { WasiIoStreams } from './interfaces/wasi-io-streams';
+import { WasiPollPoll } from './interfaces/wasi-poll-poll';
+import { WasiRandomInsecure } from './interfaces/wasi-random-insecure';
+import { WasiRandomInsecureSeed } from './interfaces/wasi-random-insecure-seed';
+import { WasiRandomRandom } from './interfaces/wasi-random-random';
+import { WasiSocketsInstanceNetwork } from './interfaces/wasi-sockets-instance-network';
+import { WasiSocketsIpNameLookup } from './interfaces/wasi-sockets-ip-name-lookup';
+import { WasiSocketsNetwork } from './interfaces/wasi-sockets-network';
+import { WasiSocketsTcp } from './interfaces/wasi-sockets-tcp';
+import { WasiSocketsTcpCreateSocket } from './interfaces/wasi-sockets-tcp-create-socket';
+import { WasiSocketsUdp } from './interfaces/wasi-sockets-udp';
+import { WasiSocketsUdpCreateSocket } from './interfaces/wasi-sockets-udp-create-socket';
+import { WasiCliRun } from './interfaces/wasi-cli-run';
 export const run: typeof WasiCliRun;

package/types/exports/wasi-cli-stderr.d.ts

@@ -1,5 +0,0 @@
-export namespace WasiCliStderr {
-  export function getStderr(): OutputStream;
-}
-import type { OutputStream } from '../exports/wasi-io-streams';
-export { OutputStream };

package/types/exports/wasi-cli-stdout.d.ts

@@ -1,5 +0,0 @@
-export namespace WasiCliStdout {
-  export function getStdout(): OutputStream;
-}
-import type { OutputStream } from '../exports/wasi-io-streams';
-export { OutputStream };

package/types/exports/wasi-cli-terminal-stderr.d.ts

@@ -1,9 +0,0 @@
-export namespace WasiCliTerminalStderr {
-  /**
-   * If stderr is connected to a terminal, return a `terminal-output` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStderr(): TerminalOutput | null;
-}
-import type { TerminalOutput } from '../exports/wasi-cli-terminal-output';
-export { TerminalOutput };

package/types/exports/wasi-cli-terminal-stdin.d.ts

@@ -1,9 +0,0 @@
-export namespace WasiCliTerminalStdin {
-  /**
-   * If stdin is connected to a terminal, return a `terminal-input` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStdin(): TerminalInput | null;
-}
-import type { TerminalInput } from '../exports/wasi-cli-terminal-input';
-export { TerminalInput };

package/types/exports/wasi-cli-terminal-stdout.d.ts

@@ -1,9 +0,0 @@
-export namespace WasiCliTerminalStdout {
-  /**
-   * If stdout is connected to a terminal, return a `terminal-output` handle
-   * allowing further interaction with it.
-   */
-  export function getTerminalStdout(): TerminalOutput | null;
-}
-import type { TerminalOutput } from '../exports/wasi-cli-terminal-output';
-export { TerminalOutput };

package/types/exports/wasi-clocks-monotonic-clock.d.ts

@@ -1,24 +0,0 @@
-export namespace WasiClocksMonotonicClock {
-  /**
-   * Read the current value of the clock.
-   * 
-   * The clock is monotonic, therefore calling this function repeatedly will
-   * produce a sequence of non-decreasing values.
-   */
-  export function now(): Instant;
-  /**
-   * Query the resolution of the clock.
-   */
-  export function resolution(): Instant;
-  /**
-   * Create a `pollable` which will resolve once the specified time has been
-   * reached.
-   */
-  export function subscribe(when: Instant, absolute: boolean): Pollable;
-}
-import type { Pollable } from '../exports/wasi-poll-poll';
-export { Pollable };
-/**
- * A timestamp in nanoseconds.
- */
-export type Instant = bigint;