@bytecodealliance/preview2-shim 0.16.0 → 0.16.2

package/types/interfaces/wasi-http-types.d.ts

@@ -13,356 +13,27 @@ export namespace WasiHttpTypes {
    * http-related errors.
    */
   export function httpErrorCode(err: IoError): ErrorCode | undefined;
-  /**
-   * Construct an empty HTTP Fields.
-   * 
-   * The resulting `fields` is mutable.
-   */
   export { Fields };
-  /**
-   * Construct an HTTP Fields.
-   * 
-   * The resulting `fields` is mutable.
-   * 
-   * The list represents each key-value pair in the Fields. Keys
-   * which have multiple values are represented by multiple entries in this
-   * list with the same key.
-   * 
-   * The tuple is a pair of the field key, represented as a string, and
-   * Value, represented as a list of bytes. In a valid Fields, all keys
-   * and values are valid UTF-8 strings. However, values are not always
-   * well-formed, so they are represented as a raw list of bytes.
-   * 
-   * An error result will be returned if any header or value was
-   * syntactically invalid, or if a header was forbidden.
-   */
-  /**
-   * Get all of the values corresponding to a key. If the key is not present
-   * in this `fields`, an empty list is returned. However, if the key is
-   * present but empty, this is represented by a list with one or more
-   * empty field-values present.
-   */
-  /**
-   * Returns `true` when the key is present in this `fields`. If the key is
-   * syntactically invalid, `false` is returned.
-   */
-  /**
-   * Set all of the values for a key. Clears any existing values for that
-   * key, if they have been set.
-   * 
-   * Fails with `header-error.immutable` if the `fields` are immutable.
-   */
-  /**
-   * Delete all values for a key. Does nothing if no values for the key
-   * exist.
-   * 
-   * Fails with `header-error.immutable` if the `fields` are immutable.
-   */
-  /**
-   * Append a value for a key. Does not change or delete any existing
-   * values for that key.
-   * 
-   * Fails with `header-error.immutable` if the `fields` are immutable.
-   */
-  /**
-   * Retrieve the full set of keys and values in the Fields. Like the
-   * constructor, the list represents each key-value pair.
-   * 
-   * The outer list represents each key-value pair in the Fields. Keys
-   * which have multiple values are represented by multiple entries in this
-   * list with the same key.
-   */
-  /**
-   * Make a deep copy of the Fields. Equivelant in behavior to calling the
-   * `fields` constructor on the return value of `entries`. The resulting
-   * `fields` is mutable.
-   */
-  /**
-   * Returns the method of the incoming request.
-   */
   export { IncomingRequest };
-  /**
-   * Returns the path with query parameters from the request, as a string.
-   */
-  /**
-   * Returns the protocol scheme from the request.
-   */
-  /**
-   * Returns the authority from the request, if it was present.
-   */
-  /**
-   * Get the `headers` associated with the request.
-   * 
-   * The returned `headers` resource is immutable: `set`, `append`, and
-   * `delete` operations will fail with `header-error.immutable`.
-   * 
-   * The `headers` returned are a child resource: it must be dropped before
-   * the parent `incoming-request` is dropped. Dropping this
-   * `incoming-request` before all children are dropped will trap.
-   */
-  /**
-   * Gives the `incoming-body` associated with this request. Will only
-   * return success at most once, and subsequent calls will return error.
-   */
-  /**
-   * Construct a new `outgoing-request` with a default `method` of `GET`, and
-   * `none` values for `path-with-query`, `scheme`, and `authority`.
-   * 
-   * * `headers` is the HTTP Headers for the Request.
-   * 
-   * It is possible to construct, or manipulate with the accessor functions
-   * below, an `outgoing-request` with an invalid combination of `scheme`
-   * and `authority`, or `headers` which are not permitted to be sent.
-   * It is the obligation of the `outgoing-handler.handle` implementation
-   * to reject invalid constructions of `outgoing-request`.
-   */
   export { OutgoingRequest };
-  /**
-   * Returns the resource corresponding to the outgoing Body for this
-   * Request.
-   * 
-   * Returns success on the first call: the `outgoing-body` resource for
-   * this `outgoing-request` can be retrieved at most once. Subsequent
-   * calls will return error.
-   */
-  /**
-   * Get the Method for the Request.
-   */
-  /**
-   * Set the Method for the Request. Fails if the string present in a
-   * `method.other` argument is not a syntactically valid method.
-   */
-  /**
-   * Get the combination of the HTTP Path and Query for the Request.
-   * When `none`, this represents an empty Path and empty Query.
-   */
-  /**
-   * Set the combination of the HTTP Path and Query for the Request.
-   * When `none`, this represents an empty Path and empty Query. Fails is the
-   * string given is not a syntactically valid path and query uri component.
-   */
-  /**
-   * Get the HTTP Related Scheme for the Request. When `none`, the
-   * implementation may choose an appropriate default scheme.
-   */
-  /**
-   * Set the HTTP Related Scheme for the Request. When `none`, the
-   * implementation may choose an appropriate default scheme. Fails if the
-   * string given is not a syntactically valid uri scheme.
-   */
-  /**
-   * Get the HTTP Authority for the Request. A value of `none` may be used
-   * with Related Schemes which do not require an Authority. The HTTP and
-   * HTTPS schemes always require an authority.
-   */
-  /**
-   * Set the HTTP Authority for the Request. A value of `none` may be used
-   * with Related Schemes which do not require an Authority. The HTTP and
-   * HTTPS schemes always require an authority. Fails if the string given is
-   * not a syntactically valid uri authority.
-   */
-  /**
-   * Get the headers associated with the Request.
-   * 
-   * The returned `headers` resource is immutable: `set`, `append`, and
-   * `delete` operations will fail with `header-error.immutable`.
-   * 
-   * This headers resource is a child: it must be dropped before the parent
-   * `outgoing-request` is dropped, or its ownership is transfered to
-   * another component by e.g. `outgoing-handler.handle`.
-   */
-  /**
-   * Construct a default `request-options` value.
-   */
   export { RequestOptions };
-  /**
-   * The timeout for the initial connect to the HTTP Server.
-   */
-  /**
-   * Set the timeout for the initial connect to the HTTP Server. An error
-   * return value indicates that this timeout is not supported.
-   */
-  /**
-   * The timeout for receiving the first byte of the Response body.
-   */
-  /**
-   * Set the timeout for receiving the first byte of the Response body. An
-   * error return value indicates that this timeout is not supported.
-   */
-  /**
-   * The timeout for receiving subsequent chunks of bytes in the Response
-   * body stream.
-   */
-  /**
-   * Set the timeout for receiving subsequent chunks of bytes in the Response
-   * body stream. An error return value indicates that this timeout is not
-   * supported.
-   */
-  /**
-   * Set the value of the `response-outparam` to either send a response,
-   * or indicate an error.
-   * 
-   * This method consumes the `response-outparam` to ensure that it is
-   * called at most once. If it is never called, the implementation
-   * will respond with an error.
-   * 
-   * The user may provide an `error` to `response` to allow the
-   * implementation determine how to respond with an HTTP error response.
-   */
   export { ResponseOutparam };
-  /**
-   * Returns the status code from the incoming response.
-   */
   export { IncomingResponse };
-  /**
-   * Returns the headers from the incoming response.
-   * 
-   * The returned `headers` resource is immutable: `set`, `append`, and
-   * `delete` operations will fail with `header-error.immutable`.
-   * 
-   * This headers resource is a child: it must be dropped before the parent
-   * `incoming-response` is dropped.
-   */
-  /**
-   * Returns the incoming body. May be called at most once. Returns error
-   * if called additional times.
-   */
-  /**
-   * Returns the contents of the body, as a stream of bytes.
-   * 
-   * Returns success on first call: the stream representing the contents
-   * can be retrieved at most once. Subsequent calls will return error.
-   * 
-   * The returned `input-stream` resource is a child: it must be dropped
-   * before the parent `incoming-body` is dropped, or consumed by
-   * `incoming-body.finish`.
-   * 
-   * This invariant ensures that the implementation can determine whether
-   * the user is consuming the contents of the body, waiting on the
-   * `future-trailers` to be ready, or neither. This allows for network
-   * backpressure is to be applied when the user is consuming the body,
-   * and for that backpressure to not inhibit delivery of the trailers if
-   * the user does not read the entire body.
-   */
   export { IncomingBody };
-  /**
-   * Takes ownership of `incoming-body`, and returns a `future-trailers`.
-   * This function will trap if the `input-stream` child is still alive.
-   */
-  /**
-   * Returns a pollable which becomes ready when either the trailers have
-   * been received, or an error has occured. When this pollable is ready,
-   * the `get` method will return `some`.
-   */
   export { FutureTrailers };
-  /**
-   * Returns the contents of the trailers, or an error which occured,
-   * once the future is ready.
-   * 
-   * The outer `option` represents future readiness. Users can wait on this
-   * `option` to become `some` using the `subscribe` method.
-   * 
-   * The outer `result` is used to retrieve the trailers or error at most
-   * once. It will be success on the first call in which the outer option
-   * is `some`, and error on subsequent calls.
-   * 
-   * The inner `result` represents that either the HTTP Request or Response
-   * body, as well as any trailers, were received successfully, or that an
-   * error occured receiving them. The optional `trailers` indicates whether
-   * or not trailers were present in the body.
-   * 
-   * When some `trailers` are returned by this method, the `trailers`
-   * resource is immutable, and a child. Use of the `set`, `append`, or
-   * `delete` methods will return an error, and the resource must be
-   * dropped before the parent `future-trailers` is dropped.
-   */
-  /**
-   * Construct an `outgoing-response`, with a default `status-code` of `200`.
-   * If a different `status-code` is needed, it must be set via the
-   * `set-status-code` method.
-   * 
-   * * `headers` is the HTTP Headers for the Response.
-   */
   export { OutgoingResponse };
-  /**
-   * Get the HTTP Status Code for the Response.
-   */
-  /**
-   * Set the HTTP Status Code for the Response. Fails if the status-code
-   * given is not a valid http status code.
-   */
-  /**
-   * Get the headers associated with the Request.
-   * 
-   * The returned `headers` resource is immutable: `set`, `append`, and
-   * `delete` operations will fail with `header-error.immutable`.
-   * 
-   * This headers resource is a child: it must be dropped before the parent
-   * `outgoing-request` is dropped, or its ownership is transfered to
-   * another component by e.g. `outgoing-handler.handle`.
-   */
-  /**
-   * Returns the resource corresponding to the outgoing Body for this Response.
-   * 
-   * Returns success on the first call: the `outgoing-body` resource for
-   * this `outgoing-response` can be retrieved at most once. Subsequent
-   * calls will return error.
-   */
-  /**
-   * Returns a stream for writing the body contents.
-   * 
-   * The returned `output-stream` is a child resource: it must be dropped
-   * before the parent `outgoing-body` resource is dropped (or finished),
-   * otherwise the `outgoing-body` drop or `finish` will trap.
-   * 
-   * Returns success on the first call: the `output-stream` resource for
-   * this `outgoing-body` may be retrieved at most once. Subsequent calls
-   * will return error.
-   */
   export { OutgoingBody };
-  /**
-   * Finalize an outgoing body, optionally providing trailers. This must be
-   * called to signal that the response is complete. If the `outgoing-body`
-   * is dropped without calling `outgoing-body.finalize`, the implementation
-   * should treat the body as corrupted.
-   * 
-   * Fails if the body's `outgoing-request` or `outgoing-response` was
-   * constructed with a Content-Length header, and the contents written
-   * to the body (via `write`) does not match the value given in the
-   * Content-Length.
-   */
-  /**
-   * Returns a pollable which becomes ready when either the Response has
-   * been received, or an error has occured. When this pollable is ready,
-   * the `get` method will return `some`.
-   */
   export { FutureIncomingResponse };
-  /**
-   * Returns the incoming HTTP Response, or an error, once one is ready.
-   * 
-   * The outer `option` represents future readiness. Users can wait on this
-   * `option` to become `some` using the `subscribe` method.
-   * 
-   * The outer `result` is used to retrieve the response or error at most
-   * once. It will be success on the first call in which the outer option
-   * is `some`, and error on subsequent calls.
-   * 
-   * The inner `result` represents that either the incoming HTTP Response
-   * status and headers have recieved successfully, or that an error
-   * occured. Errors may also occur while consuming the response body,
-   * but those will be reported by the `incoming-body` and its
-   * `output-stream` child.
-   */
 }
-import type { Duration } from '../interfaces/wasi-clocks-monotonic-clock.js';
+import type { Duration } from './wasi-clocks-monotonic-clock.js';
 export { Duration };
-import type { InputStream } from '../interfaces/wasi-io-streams.js';
+import type { InputStream } from './wasi-io-streams.js';
 export { InputStream };
-import type { OutputStream } from '../interfaces/wasi-io-streams.js';
+import type { OutputStream } from './wasi-io-streams.js';
 export { OutputStream };
-import type { Error as IoError } from '../interfaces/wasi-io-error.js';
+import type { Error as IoError } from './wasi-io-error.js';
 export { IoError };
-import type { Pollable } from '../interfaces/wasi-io-poll.js';
+import type { Pollable } from './wasi-io-poll.js';
 export { Pollable };
 /**
  * This type corresponds to HTTP standard Methods.
@@ -629,85 +300,414 @@ export type Trailers = Fields;
 export type StatusCode = number;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };
 
-export class ResponseOutparam {
-  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
-}
-
-export class OutgoingResponse {
-  constructor(headers: Headers)
-  statusCode(): StatusCode;
-  setStatusCode(statusCode: StatusCode): void;
-  headers(): Headers;
-  body(): OutgoingBody;
-}
-
-export class OutgoingBody {
-  write(): OutputStream;
-  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
-}
-
 export class Fields {
+  /**
+  * Construct an empty HTTP Fields.
+  * 
+  * The resulting `fields` is mutable.
+  */
   constructor()
+  /**
+  * Construct an HTTP Fields.
+  * 
+  * The resulting `fields` is mutable.
+  * 
+  * The list represents each key-value pair in the Fields. Keys
+  * which have multiple values are represented by multiple entries in this
+  * list with the same key.
+  * 
+  * The tuple is a pair of the field key, represented as a string, and
+  * Value, represented as a list of bytes. In a valid Fields, all keys
+  * and values are valid UTF-8 strings. However, values are not always
+  * well-formed, so they are represented as a raw list of bytes.
+  * 
+  * An error result will be returned if any header or value was
+  * syntactically invalid, or if a header was forbidden.
+  */
   static fromList(entries: [FieldKey, FieldValue][]): Fields;
+  /**
+  * Get all of the values corresponding to a key. If the key is not present
+  * in this `fields`, an empty list is returned. However, if the key is
+  * present but empty, this is represented by a list with one or more
+  * empty field-values present.
+  */
   get(name: FieldKey): FieldValue[];
+  /**
+  * Returns `true` when the key is present in this `fields`. If the key is
+  * syntactically invalid, `false` is returned.
+  */
   has(name: FieldKey): boolean;
+  /**
+  * Set all of the values for a key. Clears any existing values for that
+  * key, if they have been set.
+  * 
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  */
   set(name: FieldKey, value: FieldValue[]): void;
+  /**
+  * Delete all values for a key. Does nothing if no values for the key
+  * exist.
+  * 
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  */
   'delete'(name: FieldKey): void;
+  /**
+  * Append a value for a key. Does not change or delete any existing
+  * values for that key.
+  * 
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  */
   append(name: FieldKey, value: FieldValue): void;
+  /**
+  * Retrieve the full set of keys and values in the Fields. Like the
+  * constructor, the list represents each key-value pair.
+  * 
+  * The outer list represents each key-value pair in the Fields. Keys
+  * which have multiple values are represented by multiple entries in this
+  * list with the same key.
+  */
   entries(): [FieldKey, FieldValue][];
+  /**
+  * Make a deep copy of the Fields. Equivelant in behavior to calling the
+  * `fields` constructor on the return value of `entries`. The resulting
+  * `fields` is mutable.
+  */
   clone(): Fields;
 }
 
-export class IncomingBody {
-  stream(): InputStream;
-  static finish(this_: IncomingBody): FutureTrailers;
-}
-
 export class FutureIncomingResponse {
+  /**
+  * Returns a pollable which becomes ready when either the Response has
+  * been received, or an error has occured. When this pollable is ready,
+  * the `get` method will return `some`.
+  */
   subscribe(): Pollable;
+  /**
+  * Returns the incoming HTTP Response, or an error, once one is ready.
+  * 
+  * The outer `option` represents future readiness. Users can wait on this
+  * `option` to become `some` using the `subscribe` method.
+  * 
+  * The outer `result` is used to retrieve the response or error at most
+  * once. It will be success on the first call in which the outer option
+  * is `some`, and error on subsequent calls.
+  * 
+  * The inner `result` represents that either the incoming HTTP Response
+  * status and headers have recieved successfully, or that an error
+  * occured. Errors may also occur while consuming the response body,
+  * but those will be reported by the `incoming-body` and its
+  * `output-stream` child.
+  */
   get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
 }
 
 export class FutureTrailers {
+  /**
+  * Returns a pollable which becomes ready when either the trailers have
+  * been received, or an error has occured. When this pollable is ready,
+  * the `get` method will return `some`.
+  */
   subscribe(): Pollable;
+  /**
+  * Returns the contents of the trailers, or an error which occured,
+  * once the future is ready.
+  * 
+  * The outer `option` represents future readiness. Users can wait on this
+  * `option` to become `some` using the `subscribe` method.
+  * 
+  * The outer `result` is used to retrieve the trailers or error at most
+  * once. It will be success on the first call in which the outer option
+  * is `some`, and error on subsequent calls.
+  * 
+  * The inner `result` represents that either the HTTP Request or Response
+  * body, as well as any trailers, were received successfully, or that an
+  * error occured receiving them. The optional `trailers` indicates whether
+  * or not trailers were present in the body.
+  * 
+  * When some `trailers` are returned by this method, the `trailers`
+  * resource is immutable, and a child. Use of the `set`, `append`, or
+  * `delete` methods will return an error, and the resource must be
+  * dropped before the parent `future-trailers` is dropped.
+  */
   get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
 }
 
+export class IncomingBody {
+  /**
+  * Returns the contents of the body, as a stream of bytes.
+  * 
+  * Returns success on first call: the stream representing the contents
+  * can be retrieved at most once. Subsequent calls will return error.
+  * 
+  * The returned `input-stream` resource is a child: it must be dropped
+  * before the parent `incoming-body` is dropped, or consumed by
+  * `incoming-body.finish`.
+  * 
+  * This invariant ensures that the implementation can determine whether
+  * the user is consuming the contents of the body, waiting on the
+  * `future-trailers` to be ready, or neither. This allows for network
+  * backpressure is to be applied when the user is consuming the body,
+  * and for that backpressure to not inhibit delivery of the trailers if
+  * the user does not read the entire body.
+  */
+  stream(): InputStream;
+  /**
+  * Takes ownership of `incoming-body`, and returns a `future-trailers`.
+  * This function will trap if the `input-stream` child is still alive.
+  */
+  static finish(this_: IncomingBody): FutureTrailers;
+}
+
 export class IncomingRequest {
+  /**
+  * Returns the method of the incoming request.
+  */
   method(): Method;
+  /**
+  * Returns the path with query parameters from the request, as a string.
+  */
   pathWithQuery(): string | undefined;
+  /**
+  * Returns the protocol scheme from the request.
+  */
   scheme(): Scheme | undefined;
+  /**
+  * Returns the authority from the request, if it was present.
+  */
   authority(): string | undefined;
+  /**
+  * Get the `headers` associated with the request.
+  * 
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  * 
+  * The `headers` returned are a child resource: it must be dropped before
+  * the parent `incoming-request` is dropped. Dropping this
+  * `incoming-request` before all children are dropped will trap.
+  */
+  headers(): Headers;
+  /**
+  * Gives the `incoming-body` associated with this request. Will only
+  * return success at most once, and subsequent calls will return error.
+  */
+  consume(): IncomingBody;
+}
+
+export class IncomingResponse {
+  /**
+  * Returns the status code from the incoming response.
+  */
+  status(): StatusCode;
+  /**
+  * Returns the headers from the incoming response.
+  * 
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  * 
+  * This headers resource is a child: it must be dropped before the parent
+  * `incoming-response` is dropped.
+  */
   headers(): Headers;
+  /**
+  * Returns the incoming body. May be called at most once. Returns error
+  * if called additional times.
+  */
   consume(): IncomingBody;
 }
 
+export class OutgoingBody {
+  /**
+  * Returns a stream for writing the body contents.
+  * 
+  * The returned `output-stream` is a child resource: it must be dropped
+  * before the parent `outgoing-body` resource is dropped (or finished),
+  * otherwise the `outgoing-body` drop or `finish` will trap.
+  * 
+  * Returns success on the first call: the `output-stream` resource for
+  * this `outgoing-body` may be retrieved at most once. Subsequent calls
+  * will return error.
+  */
+  write(): OutputStream;
+  /**
+  * Finalize an outgoing body, optionally providing trailers. This must be
+  * called to signal that the response is complete. If the `outgoing-body`
+  * is dropped without calling `outgoing-body.finalize`, the implementation
+  * should treat the body as corrupted.
+  * 
+  * Fails if the body's `outgoing-request` or `outgoing-response` was
+  * constructed with a Content-Length header, and the contents written
+  * to the body (via `write`) does not match the value given in the
+  * Content-Length.
+  */
+  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
+}
+
 export class OutgoingRequest {
+  /**
+  * Construct a new `outgoing-request` with a default `method` of `GET`, and
+  * `none` values for `path-with-query`, `scheme`, and `authority`.
+  * 
+  * * `headers` is the HTTP Headers for the Request.
+  * 
+  * It is possible to construct, or manipulate with the accessor functions
+  * below, an `outgoing-request` with an invalid combination of `scheme`
+  * and `authority`, or `headers` which are not permitted to be sent.
+  * It is the obligation of the `outgoing-handler.handle` implementation
+  * to reject invalid constructions of `outgoing-request`.
+  */
   constructor(headers: Headers)
+  /**
+  * Returns the resource corresponding to the outgoing Body for this
+  * Request.
+  * 
+  * Returns success on the first call: the `outgoing-body` resource for
+  * this `outgoing-request` can be retrieved at most once. Subsequent
+  * calls will return error.
+  */
   body(): OutgoingBody;
+  /**
+  * Get the Method for the Request.
+  */
   method(): Method;
+  /**
+  * Set the Method for the Request. Fails if the string present in a
+  * `method.other` argument is not a syntactically valid method.
+  */
   setMethod(method: Method): void;
+  /**
+  * Get the combination of the HTTP Path and Query for the Request.
+  * When `none`, this represents an empty Path and empty Query.
+  */
   pathWithQuery(): string | undefined;
+  /**
+  * Set the combination of the HTTP Path and Query for the Request.
+  * When `none`, this represents an empty Path and empty Query. Fails is the
+  * string given is not a syntactically valid path and query uri component.
+  */
   setPathWithQuery(pathWithQuery: string | undefined): void;
+  /**
+  * Get the HTTP Related Scheme for the Request. When `none`, the
+  * implementation may choose an appropriate default scheme.
+  */
   scheme(): Scheme | undefined;
+  /**
+  * Set the HTTP Related Scheme for the Request. When `none`, the
+  * implementation may choose an appropriate default scheme. Fails if the
+  * string given is not a syntactically valid uri scheme.
+  */
   setScheme(scheme: Scheme | undefined): void;
+  /**
+  * Get the HTTP Authority for the Request. A value of `none` may be used
+  * with Related Schemes which do not require an Authority. The HTTP and
+  * HTTPS schemes always require an authority.
+  */
   authority(): string | undefined;
+  /**
+  * Set the HTTP Authority for the Request. A value of `none` may be used
+  * with Related Schemes which do not require an Authority. The HTTP and
+  * HTTPS schemes always require an authority. Fails if the string given is
+  * not a syntactically valid uri authority.
+  */
   setAuthority(authority: string | undefined): void;
+  /**
+  * Get the headers associated with the Request.
+  * 
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  * 
+  * This headers resource is a child: it must be dropped before the parent
+  * `outgoing-request` is dropped, or its ownership is transfered to
+  * another component by e.g. `outgoing-handler.handle`.
+  */
   headers(): Headers;
 }
 
-export class IncomingResponse {
-  status(): StatusCode;
+export class OutgoingResponse {
+  /**
+  * Construct an `outgoing-response`, with a default `status-code` of `200`.
+  * If a different `status-code` is needed, it must be set via the
+  * `set-status-code` method.
+  * 
+  * * `headers` is the HTTP Headers for the Response.
+  */
+  constructor(headers: Headers)
+  /**
+  * Get the HTTP Status Code for the Response.
+  */
+  statusCode(): StatusCode;
+  /**
+  * Set the HTTP Status Code for the Response. Fails if the status-code
+  * given is not a valid http status code.
+  */
+  setStatusCode(statusCode: StatusCode): void;
+  /**
+  * Get the headers associated with the Request.
+  * 
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  * 
+  * This headers resource is a child: it must be dropped before the parent
+  * `outgoing-request` is dropped, or its ownership is transfered to
+  * another component by e.g. `outgoing-handler.handle`.
+  */
   headers(): Headers;
-  consume(): IncomingBody;
+  /**
+  * Returns the resource corresponding to the outgoing Body for this Response.
+  * 
+  * Returns success on the first call: the `outgoing-body` resource for
+  * this `outgoing-response` can be retrieved at most once. Subsequent
+  * calls will return error.
+  */
+  body(): OutgoingBody;
 }
 
 export class RequestOptions {
+  /**
+  * Construct a default `request-options` value.
+  */
   constructor()
+  /**
+  * The timeout for the initial connect to the HTTP Server.
+  */
   connectTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for the initial connect to the HTTP Server. An error
+  * return value indicates that this timeout is not supported.
+  */
   setConnectTimeout(duration: Duration | undefined): void;
+  /**
+  * The timeout for receiving the first byte of the Response body.
+  */
   firstByteTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for receiving the first byte of the Response body. An
+  * error return value indicates that this timeout is not supported.
+  */
   setFirstByteTimeout(duration: Duration | undefined): void;
+  /**
+  * The timeout for receiving subsequent chunks of bytes in the Response
+  * body stream.
+  */
   betweenBytesTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for receiving subsequent chunks of bytes in the Response
+  * body stream. An error return value indicates that this timeout is not
+  * supported.
+  */
   setBetweenBytesTimeout(duration: Duration | undefined): void;
 }
+
+export class ResponseOutparam {
+  /**
+  * Set the value of the `response-outparam` to either send a response,
+  * or indicate an error.
+  * 
+  * This method consumes the `response-outparam` to ensure that it is
+  * called at most once. If it is never called, the implementation
+  * will respond with an error.
+  * 
+  * The user may provide an `error` to `response` to allow the
+  * implementation determine how to respond with an HTTP error response.
+  */
+  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
+}