@bytecodealliance/preview2-shim 0.17.1 → 0.17.2

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

@@ -1,19 +1,16 @@
-export namespace WasiHttpIncomingHandler {
-  /**
-   * 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;
-}
-import type { IncomingRequest } from './wasi-http-types.js';
-export { IncomingRequest };
-import type { ResponseOutparam } from './wasi-http-types.js';
-export { ResponseOutparam };
+/** @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/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -1,23 +1,18 @@
-export namespace WasiHttpOutgoingHandler {
-  /**
-   * 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;
-}
-import type { OutgoingRequest } from './wasi-http-types.js';
-export { OutgoingRequest };
-import type { RequestOptions } from './wasi-http-types.js';
-export { RequestOptions };
-import type { FutureIncomingResponse } from './wasi-http-types.js';
-export { FutureIncomingResponse };
-import type { ErrorCode } from './wasi-http-types.js';
-export { ErrorCode };
+/** @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;

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

@@ -1,40 +1,23 @@
-export namespace WasiHttpTypes {
-  /**
-   * Attempts to extract a http-related `error` from the wasi:io `error`
-   * provided.
-   * 
-   * Stream operations which return
-   * `wasi:io/stream/stream-error::last-operation-failed` have a payload of
-   * type `wasi:io/error/error` with more information about the operation
-   * that failed. This payload can be passed through to this function to see
-   * if there's http-related information about the error to return.
-   * 
-   * Note that this function is fallible because not all io-errors are
-   * http-related errors.
-   */
-  export function httpErrorCode(err: IoError): ErrorCode | undefined;
-  export { Fields };
-  export { IncomingRequest };
-  export { OutgoingRequest };
-  export { RequestOptions };
-  export { ResponseOutparam };
-  export { IncomingResponse };
-  export { IncomingBody };
-  export { FutureTrailers };
-  export { OutgoingResponse };
-  export { OutgoingBody };
-  export { FutureIncomingResponse };
-}
-import type { Duration } from './wasi-clocks-monotonic-clock.js';
-export { Duration };
-import type { InputStream } from './wasi-io-streams.js';
-export { InputStream };
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
-import type { Error as IoError } from './wasi-io-error.js';
-export { IoError };
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @module Interface wasi:http/types@0.2.3 **/
+/**
+ * Attempts to extract a http-related `error` from the wasi:io `error`
+ * provided.
+ * 
+ * Stream operations which return
+ * `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+ * type `wasi:io/error/error` with more information about the operation
+ * that failed. This payload can be passed through to this function to see
+ * if there's http-related information about the error to return.
+ * 
+ * Note that this function is fallible because not all io-errors are
+ * http-related errors.
+ */
+export function httpErrorCode(err: IoError): ErrorCode | undefined;
+export type Duration = import('./wasi-clocks-monotonic-clock.js').Duration;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type IoError = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
 /**
  * This type corresponds to HTTP standard Methods.
  */
@@ -107,7 +90,7 @@ export interface FieldSizePayload {
 }
 /**
  * These cases are inspired by the IANA HTTP Proxy Error Types:
- * https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types
+ *   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
  */
 export type ErrorCode = ErrorCodeDnsTimeout | ErrorCodeDnsError | ErrorCodeDestinationNotFound | ErrorCodeDestinationUnavailable | ErrorCodeDestinationIpProhibited | ErrorCodeDestinationIpUnroutable | ErrorCodeConnectionRefused | ErrorCodeConnectionTerminated | ErrorCodeConnectionTimeout | ErrorCodeConnectionReadTimeout | ErrorCodeConnectionWriteTimeout | ErrorCodeConnectionLimitReached | ErrorCodeTlsProtocolError | ErrorCodeTlsCertificateError | ErrorCodeTlsAlertReceived | ErrorCodeHttpRequestDenied | ErrorCodeHttpRequestLengthRequired | ErrorCodeHttpRequestBodySize | ErrorCodeHttpRequestMethodInvalid | ErrorCodeHttpRequestUriInvalid | ErrorCodeHttpRequestUriTooLong | ErrorCodeHttpRequestHeaderSectionSize | ErrorCodeHttpRequestHeaderSize | ErrorCodeHttpRequestTrailerSectionSize | ErrorCodeHttpRequestTrailerSize | ErrorCodeHttpResponseIncomplete | ErrorCodeHttpResponseHeaderSectionSize | ErrorCodeHttpResponseHeaderSize | ErrorCodeHttpResponseBodySize | ErrorCodeHttpResponseTrailerSectionSize | ErrorCodeHttpResponseTrailerSize | ErrorCodeHttpResponseTransferCoding | ErrorCodeHttpResponseContentCoding | ErrorCodeHttpResponseTimeout | ErrorCodeHttpUpgradeFailed | ErrorCodeHttpProtocolError | ErrorCodeLoopDetected | ErrorCodeConfigurationError | ErrorCodeInternalError;
 export interface ErrorCodeDnsTimeout {
@@ -400,6 +383,10 @@ export class Fields {
 }
 
 export class FutureIncomingResponse {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a pollable which becomes ready when either the Response has
   * been received, or an error has occurred. When this pollable is ready,
@@ -426,6 +413,10 @@ export class FutureIncomingResponse {
 }
 
 export class FutureTrailers {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a pollable which becomes ready when either the trailers have
   * been received, or an error has occurred. When this pollable is ready,
@@ -457,6 +448,10 @@ export class FutureTrailers {
 }
 
 export class IncomingBody {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the contents of the body, as a stream of bytes.
   * 
@@ -483,6 +478,10 @@ export class IncomingBody {
 }
 
 export class IncomingRequest {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the method of the incoming request.
   */
@@ -518,6 +517,10 @@ export class IncomingRequest {
 }
 
 export class IncomingResponse {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the status code from the incoming response.
   */
@@ -540,6 +543,10 @@ export class IncomingResponse {
 }
 
 export class OutgoingBody {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a stream for writing the body contents.
   * 
@@ -722,6 +729,10 @@ export class RequestOptions {
 }
 
 export class ResponseOutparam {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Set the value of the `response-outparam` to either send a response,
   * or indicate an error.

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

@@ -1,8 +1,10 @@
-export namespace WasiIoError {
-  export { Error };
-}
+/** @module Interface wasi:io/error@0.2.3 **/
 
 export class Error {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a string that is suitable to assist humans in debugging
   * this error.

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

@@ -1,30 +1,32 @@
-export namespace WasiIoPoll {
-  export { Pollable };
-  /**
-   * Poll for completion on a set of pollables.
-   * 
-   * This function takes a list of pollables, which identify I/O sources of
-   * interest, and waits until one or more of the events is ready for I/O.
-   * 
-   * The result `list<u32>` contains one or more indices of handles in the
-   * argument list that is ready for I/O.
-   * 
-   * This function traps if either:
-   * - the list is empty, or:
-   * - the list contains more elements than can be indexed with a `u32` value.
-   * 
-   * A timeout can be implemented by adding a pollable from the
-   * wasi-clocks API to the list.
-   * 
-   * This function does not return a `result`; polling in itself does not
-   * do any I/O so it doesn't fail. If any of the I/O sources identified by
-   * the pollables has an error, it is indicated by marking the source as
-   * being ready for I/O.
-   */
-  export function poll(in_: Array<Pollable>): Uint32Array;
-}
+/** @module Interface wasi:io/poll@0.2.3 **/
+/**
+ * Poll for completion on a set of pollables.
+ * 
+ * This function takes a list of pollables, which identify I/O sources of
+ * interest, and waits until one or more of the events is ready for I/O.
+ * 
+ * The result `list<u32>` contains one or more indices of handles in the
+ * argument list that is ready for I/O.
+ * 
+ * This function traps if either:
+ * - the list is empty, or:
+ * - the list contains more elements than can be indexed with a `u32` value.
+ * 
+ * A timeout can be implemented by adding a pollable from the
+ * wasi-clocks API to the list.
+ * 
+ * This function does not return a `result`; polling in itself does not
+ * do any I/O so it doesn't fail. If any of the I/O sources identified by
+ * the pollables has an error, it is indicated by marking the source as
+ * being ready for I/O.
+ */
+export function poll(in_: Array<Pollable>): Uint32Array;
 
 export class Pollable {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Return the readiness of a pollable. This function never blocks.
   * 

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

@@ -1,11 +1,6 @@
-export namespace WasiIoStreams {
-  export { InputStream };
-  export { OutputStream };
-}
-import type { Error } from './wasi-io-error.js';
-export { Error };
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @module Interface wasi:io/streams@0.2.3 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
 /**
  * An error for input-stream and output-stream operations.
  */
@@ -32,6 +27,10 @@ export interface StreamErrorClosed {
 }
 
 export class InputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Perform a non-blocking read from the stream.
   * 
@@ -90,6 +89,10 @@ export class InputStream {
 }
 
 export class OutputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Check readiness for writing. This function never blocks.
   * 
@@ -129,13 +132,13 @@ export class OutputStream {
   * ```text
   * let pollable = this.subscribe();
   * while !contents.is_empty() {
-    * // Wait for the stream to become writable
-    * pollable.block();
-    * let Ok(n) = this.check-write(); // eliding error handling
-    * let len = min(n, contents.len());
-    * let (chunk, rest) = contents.split_at(len);
-    * this.write(chunk  );            // eliding error handling
-    * contents = rest;
+    *     // Wait for the stream to become writable
+    *     pollable.block();
+    *     let Ok(n) = this.check-write(); // eliding error handling
+    *     let len = min(n, contents.len());
+    *     let (chunk, rest) = contents.split_at(len);
+    *     this.write(chunk  );            // eliding error handling
+    *     contents = rest;
     * }
     * this.flush();
     * // Wait for completion of `flush`
@@ -197,12 +200,12 @@ export class OutputStream {
     * ```text
     * let pollable = this.subscribe();
     * while num_zeroes != 0 {
-      * // Wait for the stream to become writable
-      * pollable.block();
-      * let Ok(n) = this.check-write(); // eliding error handling
-      * let len = min(n, num_zeroes);
-      * this.write-zeroes(len);         // eliding error handling
-      * num_zeroes -= len;
+      *     // Wait for the stream to become writable
+      *     pollable.block();
+      *     let Ok(n) = this.check-write(); // eliding error handling
+      *     let len = min(n, num_zeroes);
+      *     this.write-zeroes(len);         // eliding error handling
+      *     num_zeroes -= len;
       * }
       * this.flush();
       * // Wait for completion of `flush`

package/types/interfaces/wasi-random-insecure-seed.d.ts

@@ -1,22 +1,21 @@
-export namespace WasiRandomInsecureSeed {
-  /**
-   * Return a 128-bit value that may contain a pseudo-random value.
-   * 
-   * The returned value is not required to be computed from a CSPRNG, and may
-   * even be entirely deterministic. Host implementations are encouraged to
-   * provide pseudo-random values to any program exposed to
-   * attacker-controlled content, to enable DoS protection built into many
-   * languages' hash-map implementations.
-   * 
-   * This function is intended to only be called once, by a source language
-   * to initialize Denial Of Service (DoS) protection in its hash-map
-   * implementation.
-   * 
-   * # Expected future evolution
-   * 
-   * This will likely be changed to a value import, to prevent it from being
-   * called multiple times and potentially used for purposes other than DoS
-   * protection.
-   */
-  export function insecureSeed(): [bigint, bigint];
-}
+/** @module Interface wasi:random/insecure-seed@0.2.3 **/
+/**
+ * Return a 128-bit value that may contain a pseudo-random value.
+ * 
+ * The returned value is not required to be computed from a CSPRNG, and may
+ * even be entirely deterministic. Host implementations are encouraged to
+ * provide pseudo-random values to any program exposed to
+ * attacker-controlled content, to enable DoS protection built into many
+ * languages' hash-map implementations.
+ * 
+ * This function is intended to only be called once, by a source language
+ * to initialize Denial Of Service (DoS) protection in its hash-map
+ * implementation.
+ * 
+ * # Expected future evolution
+ * 
+ * This will likely be changed to a value import, to prevent it from being
+ * called multiple times and potentially used for purposes other than DoS
+ * protection.
+ */
+export function insecureSeed(): [bigint, bigint];

package/types/interfaces/wasi-random-insecure.d.ts

@@ -1,20 +1,19 @@
-export namespace WasiRandomInsecure {
-  /**
-   * Return `len` insecure pseudo-random bytes.
-   * 
-   * This function is not cryptographically secure. Do not use it for
-   * anything related to security.
-   * 
-   * There are no requirements on the values of the returned bytes, however
-   * implementations are encouraged to return evenly distributed values with
-   * a long period.
-   */
-  export function getInsecureRandomBytes(len: bigint): Uint8Array;
-  /**
-   * Return an insecure pseudo-random `u64` value.
-   * 
-   * This function returns the same type of pseudo-random data as
-   * `get-insecure-random-bytes`, represented as a `u64`.
-   */
-  export function getInsecureRandomU64(): bigint;
-}
+/** @module Interface wasi:random/insecure@0.2.3 **/
+/**
+ * Return `len` insecure pseudo-random bytes.
+ * 
+ * This function is not cryptographically secure. Do not use it for
+ * anything related to security.
+ * 
+ * There are no requirements on the values of the returned bytes, however
+ * implementations are encouraged to return evenly distributed values with
+ * a long period.
+ */
+export function getInsecureRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return an insecure pseudo-random `u64` value.
+ * 
+ * This function returns the same type of pseudo-random data as
+ * `get-insecure-random-bytes`, represented as a `u64`.
+ */
+export function getInsecureRandomU64(): bigint;

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

@@ -1,24 +1,23 @@
-export namespace WasiRandomRandom {
-  /**
-   * Return `len` cryptographically-secure random or pseudo-random bytes.
-   * 
-   * This function must produce data at least as cryptographically secure and
-   * fast as an adequately seeded cryptographically-secure pseudo-random
-   * number generator (CSPRNG). It must not block, from the perspective of
-   * the calling program, under any circumstances, including on the first
-   * request and on requests for numbers of bytes. The returned data must
-   * always be unpredictable.
-   * 
-   * This function must always return fresh data. Deterministic environments
-   * must omit this function, rather than implementing it with deterministic
-   * data.
-   */
-  export function getRandomBytes(len: bigint): Uint8Array;
-  /**
-   * Return a cryptographically-secure random or pseudo-random `u64` value.
-   * 
-   * This function returns the same type of data as `get-random-bytes`,
-   * represented as a `u64`.
-   */
-  export function getRandomU64(): bigint;
-}
+/** @module Interface wasi:random/random@0.2.3 **/
+/**
+ * Return `len` cryptographically-secure random or pseudo-random bytes.
+ * 
+ * This function must produce data at least as cryptographically secure and
+ * fast as an adequately seeded cryptographically-secure pseudo-random
+ * number generator (CSPRNG). It must not block, from the perspective of
+ * the calling program, under any circumstances, including on the first
+ * request and on requests for numbers of bytes. The returned data must
+ * always be unpredictable.
+ * 
+ * This function must always return fresh data. Deterministic environments
+ * must omit this function, rather than implementing it with deterministic
+ * data.
+ */
+export function getRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return a cryptographically-secure random or pseudo-random `u64` value.
+ * 
+ * This function returns the same type of data as `get-random-bytes`,
+ * represented as a `u64`.
+ */
+export function getRandomU64(): bigint;

package/types/interfaces/wasi-sockets-instance-network.d.ts

@@ -1,8 +1,6 @@
-export namespace WasiSocketsInstanceNetwork {
-  /**
-   * Get a handle to the default network.
-   */
-  export function instanceNetwork(): Network;
-}
-import type { Network } from './wasi-sockets-network.js';
-export { Network };
+/** @module Interface wasi:sockets/instance-network@0.2.3 **/
+/**
+ * Get a handle to the default network.
+ */
+export function instanceNetwork(): Network;
+export type Network = import('./wasi-sockets-network.js').Network;

package/types/interfaces/wasi-sockets-ip-name-lookup.d.ts

@@ -1,39 +1,37 @@
-export namespace WasiSocketsIpNameLookup {
-  /**
-   * Resolve an internet host name to a list of IP addresses.
-   * 
-   * Unicode domain names are automatically converted to ASCII using IDNA encoding.
-   * If the input is an IP address string, the address is parsed and returned
-   * as-is without making any external requests.
-   * 
-   * See the wasi-socket proposal README.md for a comparison with getaddrinfo.
-   * 
-   * This function never blocks. It either immediately fails or immediately
-   * returns successfully with a `resolve-address-stream` that can be used
-   * to (asynchronously) fetch the results.
-   * 
-   * # Typical errors
-   * - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
-   * 
-   * # References:
-   * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
-   * - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
-   * - <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): ResolveAddressStream;
-  export { ResolveAddressStream };
-}
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
-import type { Network } from './wasi-sockets-network.js';
-export { Network };
-import type { ErrorCode } from './wasi-sockets-network.js';
-export { ErrorCode };
-import type { IpAddress } from './wasi-sockets-network.js';
-export { IpAddress };
+/** @module Interface wasi:sockets/ip-name-lookup@0.2.3 **/
+/**
+ * Resolve an internet host name to a list of IP addresses.
+ * 
+ * Unicode domain names are automatically converted to ASCII using IDNA encoding.
+ * If the input is an IP address string, the address is parsed and returned
+ * as-is without making any external requests.
+ * 
+ * See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+ * 
+ * This function never blocks. It either immediately fails or immediately
+ * returns successfully with a `resolve-address-stream` that can be used
+ * to (asynchronously) fetch the results.
+ * 
+ * # Typical errors
+ * - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+ * 
+ * # References:
+ * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+ * - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+ * - <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): ResolveAddressStream;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+export type Network = import('./wasi-sockets-network.js').Network;
+export type ErrorCode = import('./wasi-sockets-network.js').ErrorCode;
+export type IpAddress = import('./wasi-sockets-network.js').IpAddress;
 
 export class ResolveAddressStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the next address from the resolver.
   * 

package/types/interfaces/wasi-sockets-network.d.ts

@@ -1,6 +1,4 @@
-export namespace WasiSocketsNetwork {
-  export { Network };
-}
+/** @module Interface wasi:sockets/network@0.2.3 **/
 /**
  * Error codes.
  * 
@@ -159,4 +157,8 @@ export interface IpSocketAddressIpv6 {
 }
 
 export class Network {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
 }