@cosmonic-labs/openapi2mcp 0.10.0 → 0.10.2

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-filesystem-types.d.ts

@@ -0,0 +1,669 @@
+/** @module Interface wasi:filesystem/types@0.2.3 **/
+/**
+ * Attempts to extract a filesystem-related `error-code` from the stream
+ * `error` provided.
+ * 
+ * Stream operations which return `stream-error::last-operation-failed`
+ * have a payload with more information about the operation that failed.
+ * This payload can be passed through to this function to see if there's
+ * filesystem-related information about the error to return.
+ * 
+ * Note that this function is fallible because not all stream-related
+ * errors are filesystem-related errors.
+ */
+export function filesystemErrorCode(err: Error): ErrorCode | undefined;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type Error = import('./wasi-io-streams.js').Error;
+export type Datetime = import('./wasi-clocks-wall-clock.js').Datetime;
+/**
+ * File size or length of a region within a file.
+ */
+export type Filesize = bigint;
+/**
+ * The type of a filesystem object referenced by a descriptor.
+ * 
+ * Note: This was called `filetype` in earlier versions of WASI.
+ * # Variants
+ * 
+ * ## `"unknown"`
+ * 
+ * The type of the descriptor or file is unknown or is different from
+ * any of the other types specified.
+ * ## `"block-device"`
+ * 
+ * The descriptor refers to a block device inode.
+ * ## `"character-device"`
+ * 
+ * The descriptor refers to a character device inode.
+ * ## `"directory"`
+ * 
+ * The descriptor refers to a directory inode.
+ * ## `"fifo"`
+ * 
+ * The descriptor refers to a named pipe.
+ * ## `"symbolic-link"`
+ * 
+ * The file refers to a symbolic link inode.
+ * ## `"regular-file"`
+ * 
+ * The descriptor refers to a regular file inode.
+ * ## `"socket"`
+ * 
+ * The descriptor refers to a socket.
+ */
+export type DescriptorType = 'unknown' | 'block-device' | 'character-device' | 'directory' | 'fifo' | 'symbolic-link' | 'regular-file' | 'socket';
+/**
+ * Descriptor flags.
+ * 
+ * Note: This was called `fdflags` in earlier versions of WASI.
+ */
+export interface DescriptorFlags {
+  /**
+   * Read mode: Data can be read.
+   */
+  read?: boolean,
+  /**
+   * Write mode: Data can be written to.
+   */
+  write?: boolean,
+  /**
+   * Request that writes be performed according to synchronized I/O file
+   * integrity completion. The data stored in the file and the file's
+   * metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+   * 
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  fileIntegritySync?: boolean,
+  /**
+   * Request that writes be performed according to synchronized I/O data
+   * integrity completion. Only the data stored in the file is
+   * synchronized. This is similar to `O_DSYNC` in POSIX.
+   * 
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  dataIntegritySync?: boolean,
+  /**
+   * Requests that reads be performed at the same level of integrity
+   * requested for writes. This is similar to `O_RSYNC` in POSIX.
+   * 
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  requestedWriteSync?: boolean,
+  /**
+   * Mutating directories mode: Directory contents may be mutated.
+   * 
+   * When this flag is unset on a descriptor, operations using the
+   * descriptor which would create, rename, delete, modify the data or
+   * metadata of filesystem objects, or obtain another handle which
+   * would permit any of those, shall fail with `error-code::read-only` if
+   * they would otherwise succeed.
+   * 
+   * This may only be set on directories.
+   */
+  mutateDirectory?: boolean,
+}
+/**
+ * Flags determining the method of how paths are resolved.
+ */
+export interface PathFlags {
+  /**
+   * As long as the resolved path corresponds to a symbolic link, it is
+   * expanded.
+   */
+  symlinkFollow?: boolean,
+}
+/**
+ * Open flags used by `open-at`.
+ */
+export interface OpenFlags {
+  /**
+   * Create file if it does not exist, similar to `O_CREAT` in POSIX.
+   */
+  create?: boolean,
+  /**
+   * Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+   */
+  directory?: boolean,
+  /**
+   * Fail if file already exists, similar to `O_EXCL` in POSIX.
+   */
+  exclusive?: boolean,
+  /**
+   * Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+   */
+  truncate?: boolean,
+}
+/**
+ * Number of hard links to an inode.
+ */
+export type LinkCount = bigint;
+/**
+ * File attributes.
+ * 
+ * Note: This was called `filestat` in earlier versions of WASI.
+ */
+export interface DescriptorStat {
+  /**
+   * File type.
+   */
+  type: DescriptorType,
+  /**
+   * Number of hard links to the file.
+   */
+  linkCount: LinkCount,
+  /**
+   * For regular files, the file size in bytes. For symbolic links, the
+   * length in bytes of the pathname contained in the symbolic link.
+   */
+  size: Filesize,
+  /**
+   * Last data access timestamp.
+   * 
+   * If the `option` is none, the platform doesn't maintain an access
+   * timestamp for this file.
+   */
+  dataAccessTimestamp?: Datetime,
+  /**
+   * Last data modification timestamp.
+   * 
+   * If the `option` is none, the platform doesn't maintain a
+   * modification timestamp for this file.
+   */
+  dataModificationTimestamp?: Datetime,
+  /**
+   * Last file status-change timestamp.
+   * 
+   * If the `option` is none, the platform doesn't maintain a
+   * status-change timestamp for this file.
+   */
+  statusChangeTimestamp?: Datetime,
+}
+/**
+ * When setting a timestamp, this gives the value to set it to.
+ */
+export type NewTimestamp = NewTimestampNoChange | NewTimestampNow | NewTimestampTimestamp;
+/**
+ * Leave the timestamp set to its previous value.
+ */
+export interface NewTimestampNoChange {
+  tag: 'no-change',
+}
+/**
+ * Set the timestamp to the current time of the system clock associated
+ * with the filesystem.
+ */
+export interface NewTimestampNow {
+  tag: 'now',
+}
+/**
+ * Set the timestamp to the given value.
+ */
+export interface NewTimestampTimestamp {
+  tag: 'timestamp',
+  val: Datetime,
+}
+/**
+ * A directory entry.
+ */
+export interface DirectoryEntry {
+  /**
+   * The type of the file referred to by this directory entry.
+   */
+  type: DescriptorType,
+  /**
+   * The name of the object.
+   */
+  name: string,
+}
+/**
+ * Error codes returned by functions, similar to `errno` in POSIX.
+ * Not all of these error codes are returned by the functions provided by this
+ * API; some are used in higher-level library layers, and others are provided
+ * merely for alignment with POSIX.
+ * # Variants
+ * 
+ * ## `"access"`
+ * 
+ * Permission denied, similar to `EACCES` in POSIX.
+ * ## `"would-block"`
+ * 
+ * Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
+ * ## `"already"`
+ * 
+ * Connection already in progress, similar to `EALREADY` in POSIX.
+ * ## `"bad-descriptor"`
+ * 
+ * Bad descriptor, similar to `EBADF` in POSIX.
+ * ## `"busy"`
+ * 
+ * Device or resource busy, similar to `EBUSY` in POSIX.
+ * ## `"deadlock"`
+ * 
+ * Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+ * ## `"quota"`
+ * 
+ * Storage quota exceeded, similar to `EDQUOT` in POSIX.
+ * ## `"exist"`
+ * 
+ * File exists, similar to `EEXIST` in POSIX.
+ * ## `"file-too-large"`
+ * 
+ * File too large, similar to `EFBIG` in POSIX.
+ * ## `"illegal-byte-sequence"`
+ * 
+ * Illegal byte sequence, similar to `EILSEQ` in POSIX.
+ * ## `"in-progress"`
+ * 
+ * Operation in progress, similar to `EINPROGRESS` in POSIX.
+ * ## `"interrupted"`
+ * 
+ * Interrupted function, similar to `EINTR` in POSIX.
+ * ## `"invalid"`
+ * 
+ * Invalid argument, similar to `EINVAL` in POSIX.
+ * ## `"io"`
+ * 
+ * I/O error, similar to `EIO` in POSIX.
+ * ## `"is-directory"`
+ * 
+ * Is a directory, similar to `EISDIR` in POSIX.
+ * ## `"loop"`
+ * 
+ * Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+ * ## `"too-many-links"`
+ * 
+ * Too many links, similar to `EMLINK` in POSIX.
+ * ## `"message-size"`
+ * 
+ * Message too large, similar to `EMSGSIZE` in POSIX.
+ * ## `"name-too-long"`
+ * 
+ * Filename too long, similar to `ENAMETOOLONG` in POSIX.
+ * ## `"no-device"`
+ * 
+ * No such device, similar to `ENODEV` in POSIX.
+ * ## `"no-entry"`
+ * 
+ * No such file or directory, similar to `ENOENT` in POSIX.
+ * ## `"no-lock"`
+ * 
+ * No locks available, similar to `ENOLCK` in POSIX.
+ * ## `"insufficient-memory"`
+ * 
+ * Not enough space, similar to `ENOMEM` in POSIX.
+ * ## `"insufficient-space"`
+ * 
+ * No space left on device, similar to `ENOSPC` in POSIX.
+ * ## `"not-directory"`
+ * 
+ * Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+ * ## `"not-empty"`
+ * 
+ * Directory not empty, similar to `ENOTEMPTY` in POSIX.
+ * ## `"not-recoverable"`
+ * 
+ * State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+ * ## `"unsupported"`
+ * 
+ * Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+ * ## `"no-tty"`
+ * 
+ * Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+ * ## `"no-such-device"`
+ * 
+ * No such device or address, similar to `ENXIO` in POSIX.
+ * ## `"overflow"`
+ * 
+ * Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+ * ## `"not-permitted"`
+ * 
+ * Operation not permitted, similar to `EPERM` in POSIX.
+ * ## `"pipe"`
+ * 
+ * Broken pipe, similar to `EPIPE` in POSIX.
+ * ## `"read-only"`
+ * 
+ * Read-only file system, similar to `EROFS` in POSIX.
+ * ## `"invalid-seek"`
+ * 
+ * Invalid seek, similar to `ESPIPE` in POSIX.
+ * ## `"text-file-busy"`
+ * 
+ * Text file busy, similar to `ETXTBSY` in POSIX.
+ * ## `"cross-device"`
+ * 
+ * Cross-device link, similar to `EXDEV` in POSIX.
+ */
+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';
+/**
+ * File or memory access pattern advisory information.
+ * # Variants
+ * 
+ * ## `"normal"`
+ * 
+ * The application has no advice to give on its behavior with respect
+ * to the specified data.
+ * ## `"sequential"`
+ * 
+ * The application expects to access the specified data sequentially
+ * from lower offsets to higher offsets.
+ * ## `"random"`
+ * 
+ * The application expects to access the specified data in a random
+ * order.
+ * ## `"will-need"`
+ * 
+ * The application expects to access the specified data in the near
+ * future.
+ * ## `"dont-need"`
+ * 
+ * The application expects that it will not access the specified data
+ * in the near future.
+ * ## `"no-reuse"`
+ * 
+ * The application expects to access the specified data once and then
+ * not reuse it thereafter.
+ */
+export type Advice = 'normal' | 'sequential' | 'random' | 'will-need' | 'dont-need' | 'no-reuse';
+/**
+ * A 128-bit hash value, split into parts because wasm doesn't have a
+ * 128-bit integer type.
+ */
+export interface MetadataHashValue {
+  /**
+   * 64 bits of a 128-bit hash value.
+   */
+  lower: bigint,
+  /**
+   * Another 64 bits of a 128-bit hash value.
+   */
+  upper: bigint,
+}
+
+export class Descriptor {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Return a stream for reading from a file, if available.
+  * 
+  * May fail with an error-code describing why the file cannot be read.
+  * 
+  * Multiple read, write, and append streams may be active on the same open
+  * file and they do not interfere with each other.
+  * 
+  * Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+  */
+  readViaStream(offset: Filesize): InputStream;
+  /**
+  * Return a stream for writing to a file, if available.
+  * 
+  * May fail with an error-code describing why the file cannot be written.
+  * 
+  * Note: This allows using `write-stream`, which is similar to `write` in
+  * POSIX.
+  */
+  writeViaStream(offset: Filesize): OutputStream;
+  /**
+  * Return a stream for appending to a file, if available.
+  * 
+  * May fail with an error-code describing why the file cannot be appended.
+  * 
+  * Note: This allows using `write-stream`, which is similar to `write` with
+  * `O_APPEND` in POSIX.
+  */
+  appendViaStream(): OutputStream;
+  /**
+  * Provide file advisory information on a descriptor.
+  * 
+  * This is similar to `posix_fadvise` in POSIX.
+  */
+  advise(offset: Filesize, length: Filesize, advice: Advice): void;
+  /**
+  * Synchronize the data of a file to disk.
+  * 
+  * This function succeeds with no effect if the file descriptor is not
+  * opened for writing.
+  * 
+  * Note: This is similar to `fdatasync` in POSIX.
+  */
+  syncData(): void;
+  /**
+  * Get flags associated with a descriptor.
+  * 
+  * Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+  * 
+  * Note: This returns the value that was the `fs_flags` value returned
+  * from `fdstat_get` in earlier versions of WASI.
+  */
+  getFlags(): DescriptorFlags;
+  /**
+  * Get the dynamic type of a descriptor.
+  * 
+  * Note: This returns the same value as the `type` field of the `fd-stat`
+  * returned by `stat`, `stat-at` and similar.
+  * 
+  * Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+  * by `fstat` in POSIX.
+  * 
+  * Note: This returns the value that was the `fs_filetype` value returned
+  * from `fdstat_get` in earlier versions of WASI.
+  */
+  getType(): DescriptorType;
+  /**
+  * Adjust the size of an open file. If this increases the file's size, the
+  * extra bytes are filled with zeros.
+  * 
+  * Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+  */
+  setSize(size: Filesize): void;
+  /**
+  * Adjust the timestamps of an open file or directory.
+  * 
+  * Note: This is similar to `futimens` in POSIX.
+  * 
+  * Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+  */
+  setTimes(dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  /**
+  * Read from a descriptor, without using and updating the descriptor's offset.
+  * 
+  * This function returns a list of bytes containing the data that was
+  * read, along with a bool which, when true, indicates that the end of the
+  * file was reached. The returned list will contain up to `length` bytes; it
+  * may return fewer than requested, if the end of the file is reached or
+  * if the I/O operation is interrupted.
+  * 
+  * In the future, this may change to return a `stream<u8, error-code>`.
+  * 
+  * Note: This is similar to `pread` in POSIX.
+  */
+  read(length: Filesize, offset: Filesize): [Uint8Array, boolean];
+  /**
+  * Write to a descriptor, without using and updating the descriptor's offset.
+  * 
+  * It is valid to write past the end of a file; the file is extended to the
+  * extent of the write, with bytes between the previous end and the start of
+  * the write set to zero.
+  * 
+  * In the future, this may change to take a `stream<u8, error-code>`.
+  * 
+  * Note: This is similar to `pwrite` in POSIX.
+  */
+  write(buffer: Uint8Array, offset: Filesize): Filesize;
+  /**
+  * Read directory entries from a directory.
+  * 
+  * On filesystems where directories contain entries referring to themselves
+  * and their parents, often named `.` and `..` respectively, these entries
+  * are omitted.
+  * 
+  * This always returns a new stream which starts at the beginning of the
+  * directory. Multiple streams may be active on the same directory, and they
+  * do not interfere with each other.
+  */
+  readDirectory(): DirectoryEntryStream;
+  /**
+  * Synchronize the data and metadata of a file to disk.
+  * 
+  * This function succeeds with no effect if the file descriptor is not
+  * opened for writing.
+  * 
+  * Note: This is similar to `fsync` in POSIX.
+  */
+  sync(): void;
+  /**
+  * Create a directory.
+  * 
+  * Note: This is similar to `mkdirat` in POSIX.
+  */
+  createDirectoryAt(path: string): void;
+  /**
+  * Return the attributes of an open file or directory.
+  * 
+  * Note: This is similar to `fstat` in POSIX, except that it does not return
+  * device and inode information. For testing whether two descriptors refer to
+  * the same underlying filesystem object, use `is-same-object`. To obtain
+  * additional data that can be used do determine whether a file has been
+  * modified, use `metadata-hash`.
+  * 
+  * Note: This was called `fd_filestat_get` in earlier versions of WASI.
+  */
+  stat(): DescriptorStat;
+  /**
+  * Return the attributes of a file or directory.
+  * 
+  * Note: This is similar to `fstatat` in POSIX, except that it does not
+  * return device and inode information. See the `stat` description for a
+  * discussion of alternatives.
+  * 
+  * Note: This was called `path_filestat_get` in earlier versions of WASI.
+  */
+  statAt(pathFlags: PathFlags, path: string): DescriptorStat;
+  /**
+  * Adjust the timestamps of a file or directory.
+  * 
+  * Note: This is similar to `utimensat` in POSIX.
+  * 
+  * Note: This was called `path_filestat_set_times` in earlier versions of
+  * WASI.
+  */
+  setTimesAt(pathFlags: PathFlags, path: string, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  /**
+  * Create a hard link.
+  * 
+  * Note: This is similar to `linkat` in POSIX.
+  */
+  linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  /**
+  * Open a file or directory.
+  * 
+  * If `flags` contains `descriptor-flags::mutate-directory`, and the base
+  * descriptor doesn't have `descriptor-flags::mutate-directory` set,
+  * `open-at` fails with `error-code::read-only`.
+  * 
+  * If `flags` contains `write` or `mutate-directory`, or `open-flags`
+  * contains `truncate` or `create`, and the base descriptor doesn't have
+  * `descriptor-flags::mutate-directory` set, `open-at` fails with
+  * `error-code::read-only`.
+  * 
+  * Note: This is similar to `openat` in POSIX.
+  */
+  openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: DescriptorFlags): Descriptor;
+  /**
+  * Read the contents of a symbolic link.
+  * 
+  * If the contents contain an absolute or rooted path in the underlying
+  * filesystem, this function fails with `error-code::not-permitted`.
+  * 
+  * Note: This is similar to `readlinkat` in POSIX.
+  */
+  readlinkAt(path: string): string;
+  /**
+  * Remove a directory.
+  * 
+  * Return `error-code::not-empty` if the directory is not empty.
+  * 
+  * Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  */
+  removeDirectoryAt(path: string): void;
+  /**
+  * Rename a filesystem object.
+  * 
+  * Note: This is similar to `renameat` in POSIX.
+  */
+  renameAt(oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  /**
+  * Create a symbolic link (also known as a "symlink").
+  * 
+  * If `old-path` starts with `/`, the function fails with
+  * `error-code::not-permitted`.
+  * 
+  * Note: This is similar to `symlinkat` in POSIX.
+  */
+  symlinkAt(oldPath: string, newPath: string): void;
+  /**
+  * Unlink a filesystem object that is not a directory.
+  * 
+  * Return `error-code::is-directory` if the path refers to a directory.
+  * Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  */
+  unlinkFileAt(path: string): void;
+  /**
+  * Test whether two descriptors refer to the same filesystem object.
+  * 
+  * In POSIX, this corresponds to testing whether the two descriptors have the
+  * same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+  * wasi-filesystem does not expose device and inode numbers, so this function
+  * may be used instead.
+  */
+  isSameObject(other: Descriptor): boolean;
+  /**
+  * Return a hash of the metadata associated with a filesystem object referred
+  * to by a descriptor.
+  * 
+  * This returns a hash of the last-modification timestamp and file size, and
+  * may also include the inode number, device number, birth timestamp, and
+  * other metadata fields that may change when the file is modified or
+  * replaced. It may also include a secret value chosen by the
+  * implementation and not otherwise exposed.
+  * 
+  * Implementations are encouraged to provide the following properties:
+  * 
+  *  - If the file is not modified or replaced, the computed hash value should
+  *    usually not change.
+  *  - If the object is modified or replaced, the computed hash value should
+  *    usually change.
+  *  - The inputs to the hash should not be easily computable from the
+  *    computed hash.
+  * 
+  * However, none of these is required.
+  */
+  metadataHash(): MetadataHashValue;
+  /**
+  * Return a hash of the metadata associated with a filesystem object referred
+  * to by a directory descriptor and a relative path.
+  * 
+  * This performs the same hash computation as `metadata-hash`.
+  */
+  metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
+}
+
+export class DirectoryEntryStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Read a single directory entry from a `directory-entry-stream`.
+  */
+  readDirectoryEntry(): DirectoryEntry | undefined;
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-http-incoming-handler.d.ts

@@ -0,0 +1,16 @@
+/** @module Interface wasi:http/incoming-handler@0.2.3 **/
+/**
+ * This function is invoked with an incoming HTTP Request, and a resource
+ * `response-outparam` which provides the capability to reply with an HTTP
+ * Response. The response is sent by calling the `response-outparam.set`
+ * method, which allows execution to continue after the response has been
+ * sent. This enables both streaming to the response body, and performing other
+ * work.
+ * 
+ * The implementor of this function must write a response to the
+ * `response-outparam` before returning, or else the caller will respond
+ * with an error on its behalf.
+ */
+export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
+export type IncomingRequest = import('./wasi-http-types.js').IncomingRequest;
+export type ResponseOutparam = import('./wasi-http-types.js').ResponseOutparam;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -0,0 +1,18 @@
+/** @module Interface wasi:http/outgoing-handler@0.2.3 **/
+/**
+ * This function is invoked with an outgoing HTTP Request, and it returns
+ * a resource `future-incoming-response` which represents an HTTP Response
+ * which may arrive in the future.
+ * 
+ * The `options` argument accepts optional parameters for the HTTP
+ * protocol's transport layer.
+ * 
+ * This function may return an error if the `outgoing-request` is invalid
+ * or not allowed to be made. Otherwise, protocol errors are reported
+ * through the `future-incoming-response`.
+ */
+export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
+export type OutgoingRequest = import('./wasi-http-types.js').OutgoingRequest;
+export type RequestOptions = import('./wasi-http-types.js').RequestOptions;
+export type FutureIncomingResponse = import('./wasi-http-types.js').FutureIncomingResponse;
+export type ErrorCode = import('./wasi-http-types.js').ErrorCode;