@bytecodealliance/preview2-shim 0.0.3 → 0.0.5

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",
+  "types": "./types/index.d.ts",
   "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "node": "./lib/nodejs/index.js",
+      "default": "./lib/browser/index.js"
+    },
     "./*": {
-      "types": "./types/*.js",
+      "types": "./types/*.d.ts",
       "node": "./lib/nodejs/*.js",
       "default": "./lib/browser/*.js"
     }
@@ -20,5 +26,14 @@
   ],
   "devDependencies": {
     "mocha": "^10.2.0"
-  }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytecodealliance/jco.git"
+  },
+  "license": "(Apache-2.0 WITH LLVM-exception)",
+  "bugs": {
+    "url": "https://github.com/bytecodealliance/jco/issues"
+  },
+  "homepage": "https://github.com/bytecodealliance/jco#readme"
 }

package/types/exports/HTTP.d.ts

@@ -0,0 +1,7 @@
+export namespace Http {
+  export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
+}
+import type { IncomingRequest } from '../imports/types';
+export { IncomingRequest };
+import type { ResponseOutparam } from '../imports/types';
+export { ResponseOutparam };

package/types/imports/console.d.ts

@@ -0,0 +1,17 @@
+export namespace Console {
+  export function log(level: Level, context: string, message: string): void;
+}
+/**
+ * # Variants
+ * 
+ * ## `"trace"`
+ * 
+ * ## `"debug"`
+ * 
+ * ## `"info"`
+ * 
+ * ## `"warn"`
+ * 
+ * ## `"error"`
+ */
+export type Level = 'trace' | 'debug' | 'info' | 'warn' | 'error';

package/types/imports/default-outgoing-HTTP.d.ts

@@ -0,0 +1,9 @@
+export namespace DefaultOutgoingHttp {
+  export function handle(request: OutgoingRequest, options: RequestOptions | null): FutureIncomingResponse;
+}
+import type { OutgoingRequest } from '../imports/types';
+export { OutgoingRequest };
+import type { RequestOptions } from '../imports/types';
+export { RequestOptions };
+import type { FutureIncomingResponse } from '../imports/types';
+export { FutureIncomingResponse };

package/types/imports/environment-preopens.d.ts

@@ -0,0 +1,5 @@
+export namespace EnvironmentPreopens {
+  export function preopens(): [Descriptor, string][];
+}
+import type { Descriptor } from '../imports/filesystem';
+export { Descriptor };

package/types/imports/environment.d.ts

@@ -0,0 +1,3 @@
+export namespace Environment {
+  export function getEnvironment(): [string, string][];
+}

package/types/imports/exit.d.ts

@@ -0,0 +1,4 @@
+export namespace Exit {
+  export function exit(status: Result<void, void>): void;
+}
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/types/imports/filesystem.d.ts

@@ -0,0 +1,212 @@
+export namespace Filesystem {
+  export function readViaStream(this: Descriptor, offset: Filesize): InputStream;
+  export function writeViaStream(this: Descriptor, offset: Filesize): OutputStream;
+  export function appendViaStream(this: Descriptor): OutputStream;
+  export function advise(this: Descriptor, offset: Filesize, length: Filesize, advice: Advice): void;
+  export function syncData(this: Descriptor): void;
+  export function getFlags(this: Descriptor): DescriptorFlags;
+  export function getType(this: Descriptor): DescriptorType;
+  export function setFlags(this: Descriptor, flags: DescriptorFlags): void;
+  export function setSize(this: Descriptor, size: Filesize): void;
+  export function setTimes(this: Descriptor, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  export function read(this: Descriptor, length: Filesize, offset: Filesize): [Uint8Array | ArrayBuffer, boolean];
+  export function write(this: Descriptor, buffer: Uint8Array, offset: Filesize): Filesize;
+  export function readDirectory(this: Descriptor): DirectoryEntryStream;
+  export function sync(this: Descriptor): void;
+  export function createDirectoryAt(this: Descriptor, path: string): void;
+  export function stat(this: Descriptor): DescriptorStat;
+  export function statAt(this: Descriptor, pathFlags: PathFlags, path: string): DescriptorStat;
+  export function setTimesAt(this: Descriptor, pathFlags: PathFlags, path: string, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  export function linkAt(this: Descriptor, oldPathFlags: PathFlags, oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  export function openAt(this: Descriptor, pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: DescriptorFlags, modes: Modes): Descriptor;
+  export function readlinkAt(this: Descriptor, path: string): string;
+  export function removeDirectoryAt(this: Descriptor, path: string): void;
+  export function renameAt(this: Descriptor, oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  export function symlinkAt(this: Descriptor, oldPath: string, newPath: string): void;
+  export function unlinkFileAt(this: Descriptor, path: string): void;
+  export function changeFilePermissionsAt(this: Descriptor, pathFlags: PathFlags, path: string, modes: Modes): void;
+  export function changeDirectoryPermissionsAt(this: Descriptor, pathFlags: PathFlags, path: string, modes: Modes): void;
+  export function lockShared(this: Descriptor): void;
+  export function lockExclusive(this: Descriptor): void;
+  export function tryLockShared(this: Descriptor): void;
+  export function tryLockExclusive(this: Descriptor): void;
+  export function unlock(this: Descriptor): void;
+  export function dropDescriptor(this: Descriptor): void;
+  export function readDirectoryEntry(this: DirectoryEntryStream): DirectoryEntry | null;
+  export function dropDirectoryEntryStream(this: DirectoryEntryStream): void;
+}
+export type Descriptor = number;
+export type Filesize = bigint;
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+/**
+ * # Variants
+ * 
+ * ## `"normal"`
+ * 
+ * ## `"sequential"`
+ * 
+ * ## `"random"`
+ * 
+ * ## `"will-need"`
+ * 
+ * ## `"dont-need"`
+ * 
+ * ## `"no-reuse"`
+ */
+export type Advice = 'normal' | 'sequential' | 'random' | 'will-need' | 'dont-need' | 'no-reuse';
+/**
+ * # Variants
+ * 
+ * ## `"access"`
+ * 
+ * ## `"would-block"`
+ * 
+ * ## `"already"`
+ * 
+ * ## `"bad-descriptor"`
+ * 
+ * ## `"busy"`
+ * 
+ * ## `"deadlock"`
+ * 
+ * ## `"quota"`
+ * 
+ * ## `"exist"`
+ * 
+ * ## `"file-too-large"`
+ * 
+ * ## `"illegal-byte-sequence"`
+ * 
+ * ## `"in-progress"`
+ * 
+ * ## `"interrupted"`
+ * 
+ * ## `"invalid"`
+ * 
+ * ## `"io"`
+ * 
+ * ## `"is-directory"`
+ * 
+ * ## `"loop"`
+ * 
+ * ## `"too-many-links"`
+ * 
+ * ## `"message-size"`
+ * 
+ * ## `"name-too-long"`
+ * 
+ * ## `"no-device"`
+ * 
+ * ## `"no-entry"`
+ * 
+ * ## `"no-lock"`
+ * 
+ * ## `"insufficient-memory"`
+ * 
+ * ## `"insufficient-space"`
+ * 
+ * ## `"not-directory"`
+ * 
+ * ## `"not-empty"`
+ * 
+ * ## `"not-recoverable"`
+ * 
+ * ## `"unsupported"`
+ * 
+ * ## `"no-tty"`
+ * 
+ * ## `"no-such-device"`
+ * 
+ * ## `"overflow"`
+ * 
+ * ## `"not-permitted"`
+ * 
+ * ## `"pipe"`
+ * 
+ * ## `"read-only"`
+ * 
+ * ## `"invalid-seek"`
+ * 
+ * ## `"text-file-busy"`
+ * 
+ * ## `"cross-device"`
+ */
+export type ErrorCode = 'access' | 'would-block' | 'already' | 'bad-descriptor' | 'busy' | 'deadlock' | 'quota' | 'exist' | 'file-too-large' | 'illegal-byte-sequence' | 'in-progress' | 'interrupted' | 'invalid' | 'io' | 'is-directory' | 'loop' | 'too-many-links' | 'message-size' | 'name-too-long' | 'no-device' | 'no-entry' | 'no-lock' | 'insufficient-memory' | 'insufficient-space' | 'not-directory' | 'not-empty' | 'not-recoverable' | 'unsupported' | 'no-tty' | 'no-such-device' | 'overflow' | 'not-permitted' | 'pipe' | 'read-only' | 'invalid-seek' | 'text-file-busy' | 'cross-device';
+export interface DescriptorFlags {
+  read?: boolean,
+  write?: boolean,
+  nonBlocking?: boolean,
+  fileIntegritySync?: boolean,
+  dataIntegritySync?: boolean,
+  requestedWriteSync?: boolean,
+  mutateDirectory?: boolean,
+}
+/**
+ * # Variants
+ * 
+ * ## `"unknown"`
+ * 
+ * ## `"block-device"`
+ * 
+ * ## `"character-device"`
+ * 
+ * ## `"directory"`
+ * 
+ * ## `"fifo"`
+ * 
+ * ## `"symbolic-link"`
+ * 
+ * ## `"regular-file"`
+ * 
+ * ## `"socket"`
+ */
+export type DescriptorType = 'unknown' | 'block-device' | 'character-device' | 'directory' | 'fifo' | 'symbolic-link' | 'regular-file' | 'socket';
+import type { Datetime } from '../imports/wall-clock';
+export { Datetime };
+export type NewTimestamp = NewTimestampNoChange | NewTimestampNow | NewTimestampTimestamp;
+export interface NewTimestampNoChange {
+  tag: 'no-change',
+}
+export interface NewTimestampNow {
+  tag: 'now',
+}
+export interface NewTimestampTimestamp {
+  tag: 'timestamp',
+  val: Datetime,
+}
+export type DirectoryEntryStream = number;
+export type Device = bigint;
+export type Inode = bigint;
+export type LinkCount = bigint;
+export interface DescriptorStat {
+  device: Device,
+  inode: Inode,
+  type: DescriptorType,
+  linkCount: LinkCount,
+  size: Filesize,
+  dataAccessTimestamp: Datetime,
+  dataModificationTimestamp: Datetime,
+  statusChangeTimestamp: Datetime,
+}
+export interface PathFlags {
+  symlinkFollow?: boolean,
+}
+export interface OpenFlags {
+  create?: boolean,
+  directory?: boolean,
+  exclusive?: boolean,
+  truncate?: boolean,
+}
+export interface Modes {
+  readable?: boolean,
+  writeable?: boolean,
+  executable?: boolean,
+}
+export interface DirectoryEntry {
+  inode?: Inode,
+  type: DescriptorType,
+  name: string,
+}

package/types/imports/instance-monotonic-clock.d.ts

@@ -0,0 +1,5 @@
+export namespace InstanceMonotonicClock {
+  export function instanceMonotonicClock(): MonotonicClock;
+}
+import type { MonotonicClock } from '../imports/monotonic-clock';
+export { MonotonicClock };

package/types/imports/instance-network.d.ts

@@ -0,0 +1,5 @@
+export namespace InstanceNetwork {
+  export function instanceNetwork(): Network;
+}
+import type { Network } from '../imports/network';
+export { Network };

package/types/imports/instance-wall-clock.d.ts

@@ -0,0 +1,5 @@
+export namespace InstanceWallClock {
+  export function instanceWallClock(): WallClock;
+}
+import type { WallClock } from '../imports/wall-clock';
+export { WallClock };

package/types/imports/ip-name-lookup.d.ts

@@ -0,0 +1,19 @@
+export namespace IpNameLookup {
+  export function resolveAddresses(network: Network, name: string, addressFamily: IpAddressFamily | null, includeUnavailable: boolean): ResolveAddressStream;
+  export function resolveNextAddress(this: ResolveAddressStream): IpAddress | null;
+  export function dropResolveAddressStream(this: ResolveAddressStream): void;
+  export function nonBlocking(this: ResolveAddressStream): boolean;
+  export function setNonBlocking(this: ResolveAddressStream, value: boolean): void;
+  export function subscribe(this: ResolveAddressStream): Pollable;
+}
+import type { Network } from '../imports/network';
+export { Network };
+import type { IpAddressFamily } from '../imports/network';
+export { IpAddressFamily };
+export type ResolveAddressStream = number;
+import type { Error } from '../imports/network';
+export { Error };
+import type { IpAddress } from '../imports/network';
+export { IpAddress };
+import type { Pollable } from '../imports/poll';
+export { Pollable };

package/types/imports/monotonic-clock.d.ts

@@ -0,0 +1,10 @@
+export namespace MonotonicClock {
+  export function now(this: MonotonicClock): Instant;
+  export function resolution(this: MonotonicClock): Instant;
+  export function subscribe(this: MonotonicClock, when: Instant, absolute: boolean): Pollable;
+  export function dropMonotonicClock(this: MonotonicClock): void;
+}
+export type MonotonicClock = number;
+export type Instant = bigint;
+import type { Pollable } from '../imports/poll';
+export { Pollable };

package/types/imports/network.d.ts

@@ -0,0 +1,50 @@
+export namespace Network {
+  export function dropNetwork(this: Network): void;
+}
+export type Network = number;
+export type Ipv6Address = [number, number, number, number, number, number, number, number];
+export interface Ipv6SocketAddress {
+  port: number,
+  flowInfo: number,
+  address: Ipv6Address,
+  scopeId: number,
+}
+export type Ipv4Address = [number, number, number, number];
+export interface Ipv4SocketAddress {
+  port: number,
+  address: Ipv4Address,
+}
+export type IpSocketAddress = IpSocketAddressIpv4 | IpSocketAddressIpv6;
+export interface IpSocketAddressIpv4 {
+  tag: 'ipv4',
+  val: Ipv4SocketAddress,
+}
+export interface IpSocketAddressIpv6 {
+  tag: 'ipv6',
+  val: Ipv6SocketAddress,
+}
+export type IpAddress = IpAddressIpv4 | IpAddressIpv6;
+export interface IpAddressIpv4 {
+  tag: 'ipv4',
+  val: Ipv4Address,
+}
+export interface IpAddressIpv6 {
+  tag: 'ipv6',
+  val: Ipv6Address,
+}
+/**
+ * # Variants
+ * 
+ * ## `"unknown"`
+ * 
+ * ## `"again"`
+ */
+export type Error = 'unknown' | 'again';
+/**
+ * # Variants
+ * 
+ * ## `"ipv4"`
+ * 
+ * ## `"ipv6"`
+ */
+export type IpAddressFamily = 'ipv4' | 'ipv6';

package/types/imports/poll.d.ts

@@ -0,0 +1,5 @@
+export namespace Poll {
+  export function dropPollable(this: Pollable): void;
+  export function pollOneoff(in_: Uint32Array): Uint8Array | ArrayBuffer;
+}
+export type Pollable = number;

package/types/imports/preopens.d.ts

@@ -0,0 +1,15 @@
+export namespace Preopens {
+  export function getStdio(): StdioPreopens;
+  export function getDirectories(): [Descriptor, string][];
+}
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+export interface StdioPreopens {
+  stdin: InputStream,
+  stdout: OutputStream,
+  stderr: OutputStream,
+}
+import type { Descriptor } from '../imports/filesystem';
+export { Descriptor };

package/types/imports/random.d.ts

@@ -0,0 +1,5 @@
+export namespace Random {
+  export function getRandomBytes(len: bigint): Uint8Array | ArrayBuffer;
+  export function getRandomU64(): bigint;
+  export function insecureRandom(): [bigint, bigint];
+}

package/types/{wasi-stderr.d.ts → imports/stderr.d.ts}

@@ -1,3 +1,3 @@
-export namespace WasiStderr {
+export namespace Stderr {
   export function print(message: string): void;
 }

package/types/imports/streams.d.ts

@@ -0,0 +1,23 @@
+export namespace Streams {
+  export function read(this: InputStream, len: bigint): [Uint8Array | ArrayBuffer, boolean];
+  export function blockingRead(this: InputStream, len: bigint): [Uint8Array | ArrayBuffer, boolean];
+  export function skip(this: InputStream, len: bigint): [bigint, boolean];
+  export function blockingSkip(this: InputStream, len: bigint): [bigint, boolean];
+  export function subscribeToInputStream(this: InputStream): Pollable;
+  export function dropInputStream(this: InputStream): void;
+  export function write(this: OutputStream, buf: Uint8Array): bigint;
+  export function blockingWrite(this: OutputStream, buf: Uint8Array): bigint;
+  export function writeZeroes(this: OutputStream, len: bigint): bigint;
+  export function blockingWriteZeroes(this: OutputStream, len: bigint): bigint;
+  export function splice(this: OutputStream, src: InputStream, len: bigint): [bigint, boolean];
+  export function blockingSplice(this: OutputStream, src: InputStream, len: bigint): [bigint, boolean];
+  export function forward(this: OutputStream, src: InputStream): bigint;
+  export function subscribeToOutputStream(this: OutputStream): Pollable;
+  export function dropOutputStream(this: OutputStream): void;
+}
+export type InputStream = number;
+export interface StreamError {
+}
+import type { Pollable } from '../imports/poll';
+export { Pollable };
+export type OutputStream = number;

package/types/imports/tcp-create-socket.d.ts

@@ -0,0 +1,9 @@
+export namespace TcpCreateSocket {
+  export function createTcpSocket(addressFamily: IpAddressFamily): TcpSocket;
+}
+import type { IpAddressFamily } from '../imports/network';
+export { IpAddressFamily };
+import type { TcpSocket } from '../imports/tcp';
+export { TcpSocket };
+import type { Error } from '../imports/network';
+export { Error };

package/types/imports/tcp.d.ts

@@ -0,0 +1,52 @@
+export namespace Tcp {
+  export function bind(this: TcpSocket, network: Network, localAddress: IpSocketAddress): void;
+  export function connect(this: TcpSocket, network: Network, remoteAddress: IpSocketAddress): [InputStream, OutputStream];
+  export function listen(this: TcpSocket, network: Network): void;
+  export function accept(this: TcpSocket): [TcpSocket, InputStream, OutputStream];
+  export function localAddress(this: TcpSocket): IpSocketAddress;
+  export function remoteAddress(this: TcpSocket): IpSocketAddress;
+  export function addressFamily(this: TcpSocket): IpAddressFamily;
+  export function ipv6Only(this: TcpSocket): boolean;
+  export function setIpv6Only(this: TcpSocket, value: boolean): void;
+  export function setListenBacklogSize(this: TcpSocket, value: bigint): void;
+  export function keepAlive(this: TcpSocket): boolean;
+  export function setKeepAlive(this: TcpSocket, value: boolean): void;
+  export function noDelay(this: TcpSocket): boolean;
+  export function setNoDelay(this: TcpSocket, value: boolean): void;
+  export function unicastHopLimit(this: TcpSocket): number;
+  export function setUnicastHopLimit(this: TcpSocket, value: number): void;
+  export function receiveBufferSize(this: TcpSocket): bigint;
+  export function setReceiveBufferSize(this: TcpSocket, value: bigint): void;
+  export function sendBufferSize(this: TcpSocket): bigint;
+  export function setSendBufferSize(this: TcpSocket, value: bigint): void;
+  export function nonBlocking(this: TcpSocket): boolean;
+  export function setNonBlocking(this: TcpSocket, value: boolean): void;
+  export function subscribe(this: TcpSocket): Pollable;
+  export function shutdown(this: TcpSocket, shutdownType: ShutdownType): void;
+  export function dropTcpSocket(this: TcpSocket): void;
+}
+export type TcpSocket = number;
+import type { Network } from '../imports/network';
+export { Network };
+import type { IpSocketAddress } from '../imports/network';
+export { IpSocketAddress };
+import type { Error } from '../imports/network';
+export { Error };
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+import type { IpAddressFamily } from '../imports/network';
+export { IpAddressFamily };
+import type { Pollable } from '../imports/poll';
+export { Pollable };
+/**
+ * # Variants
+ * 
+ * ## `"receive"`
+ * 
+ * ## `"send"`
+ * 
+ * ## `"both"`
+ */
+export type ShutdownType = 'receive' | 'send' | 'both';

package/types/imports/timezone.d.ts

@@ -0,0 +1,13 @@
+export namespace Timezone {
+  export function display(this: Timezone, when: Datetime): TimezoneDisplay;
+  export function utcOffset(this: Timezone, when: Datetime): number;
+  export function dropTimezone(this: Timezone): void;
+}
+export type Timezone = number;
+import type { Datetime } from '../imports/wall-clock';
+export { Datetime };
+export interface TimezoneDisplay {
+  utcOffset: number,
+  name: string,
+  inDaylightSavingTime: boolean,
+}

package/types/imports/types.d.ts

@@ -0,0 +1,119 @@
+export namespace Types {
+  export function dropFields(fields: Fields): void;
+  export function newFields(entries: [string, string][]): Fields;
+  export function fieldsGet(fields: Fields, name: string): string[];
+  export function fieldsSet(fields: Fields, name: string, value: string[]): void;
+  export function fieldsDelete(fields: Fields, name: string): void;
+  export function fieldsAppend(fields: Fields, name: string, value: string): void;
+  export function fieldsEntries(fields: Fields): [string, string][];
+  export function fieldsClone(fields: Fields): Fields;
+  export function finishIncomingStream(s: IncomingStream): Trailers | null;
+  export function finishOutgoingStream(s: OutgoingStream, trailers: Trailers | null): void;
+  export function dropIncomingRequest(request: IncomingRequest): void;
+  export function dropOutgoingRequest(request: OutgoingRequest): void;
+  export function incomingRequestMethod(request: IncomingRequest): Method;
+  export function incomingRequestPath(request: IncomingRequest): string;
+  export function incomingRequestQuery(request: IncomingRequest): string;
+  export function incomingRequestScheme(request: IncomingRequest): Scheme | null;
+  export function incomingRequestAuthority(request: IncomingRequest): string;
+  export function incomingRequestHeaders(request: IncomingRequest): Headers;
+  export function incomingRequestConsume(request: IncomingRequest): IncomingStream;
+  export function newOutgoingRequest(method: Method, path: string, query: string, scheme: Scheme | null, authority: string, headers: Headers): OutgoingRequest;
+  export function outgoingRequestWrite(request: OutgoingRequest): OutgoingStream;
+  export function dropResponseOutparam(response: ResponseOutparam): void;
+  export function setResponseOutparam(response: Result<OutgoingResponse, Error>): void;
+  export function dropIncomingResponse(response: IncomingResponse): void;
+  export function dropOutgoingResponse(response: OutgoingResponse): void;
+  export function incomingResponseStatus(response: IncomingResponse): StatusCode;
+  export function incomingResponseHeaders(response: IncomingResponse): Headers;
+  export function incomingResponseConsume(response: IncomingResponse): IncomingStream;
+  export function newOutgoingResponse(statusCode: StatusCode, headers: Headers): OutgoingResponse;
+  export function outgoingResponseWrite(response: OutgoingResponse): OutgoingStream;
+  export function dropFutureIncomingResponse(f: FutureIncomingResponse): void;
+  export function futureIncomingResponseGet(f: FutureIncomingResponse): Result<IncomingResponse, Error> | null;
+  export function listenToFutureIncomingResponse(f: FutureIncomingResponse): Pollable;
+}
+export type Fields = number;
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+export type IncomingStream = InputStream;
+export type Trailers = Fields;
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+export type OutgoingStream = OutputStream;
+export type IncomingRequest = number;
+export type OutgoingRequest = number;
+export type Method = MethodGet | MethodHead | MethodPost | MethodPut | MethodDelete | MethodConnect | MethodOptions | MethodTrace | MethodPatch | MethodOther;
+export interface MethodGet {
+  tag: 'get',
+}
+export interface MethodHead {
+  tag: 'head',
+}
+export interface MethodPost {
+  tag: 'post',
+}
+export interface MethodPut {
+  tag: 'put',
+}
+export interface MethodDelete {
+  tag: 'delete',
+}
+export interface MethodConnect {
+  tag: 'connect',
+}
+export interface MethodOptions {
+  tag: 'options',
+}
+export interface MethodTrace {
+  tag: 'trace',
+}
+export interface MethodPatch {
+  tag: 'patch',
+}
+export interface MethodOther {
+  tag: 'other',
+  val: string,
+}
+export type Scheme = SchemeHttp | SchemeHttps | SchemeOther;
+export interface SchemeHttp {
+  tag: 'HTTP',
+}
+export interface SchemeHttps {
+  tag: 'HTTPS',
+}
+export interface SchemeOther {
+  tag: 'other',
+  val: string,
+}
+export type Headers = Fields;
+export type ResponseOutparam = number;
+export type OutgoingResponse = number;
+export type Error = ErrorInvalidUrl | ErrorTimeoutError | ErrorProtocolError | ErrorUnexpectedError;
+export interface ErrorInvalidUrl {
+  tag: 'invalid-url',
+  val: string,
+}
+export interface ErrorTimeoutError {
+  tag: 'timeout-error',
+  val: string,
+}
+export interface ErrorProtocolError {
+  tag: 'protocol-error',
+  val: string,
+}
+export interface ErrorUnexpectedError {
+  tag: 'unexpected-error',
+  val: string,
+}
+export type IncomingResponse = number;
+export type StatusCode = number;
+export type FutureIncomingResponse = number;
+import type { Pollable } from '../imports/poll';
+export { Pollable };
+export interface RequestOptions {
+  connectTimeoutMs?: number,
+  firstByteTimeoutMs?: number,
+  betweenBytesTimeoutMs?: number,
+}
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };