hapii-js 0.0.0-stage → 2.0.0

package/lib/types/server/ext.d.ts

@@ -0,0 +1,152 @@
+import { Server, ServerApplicationState } from './server';
+import { ReqRef, ReqRefDefaults } from '../request';
+import { Lifecycle } from '../utils';
+
+/**
+ * The extension point event name. The available extension points include the request extension points as well as the following server extension points:
+ * 'onPreStart' - called before the connection listeners are started.
+ * 'onPostStart' - called after the connection listeners are started.
+ * 'onPreStop' - called before the connection listeners are stopped.
+ * 'onPostStop' - called after the connection listeners are stopped.
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevents)
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#request-lifecycle)
+ */
+export type ServerExtType = 'onPreStart' | 'onPostStart' | 'onPreStop' | 'onPostStop';
+export type RouteRequestExtType = 'onPreAuth'
+    | 'onCredentials'
+    | 'onPostAuth'
+    | 'onPreHandler'
+    | 'onPostHandler'
+    | 'onPreResponse'
+    | 'onPostResponse';
+
+export type ServerRequestExtType =
+    RouteRequestExtType
+    | 'onRequest';
+
+/**
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevents)
+ * Registers an extension function in one of the request lifecycle extension points where:
+ * @param events - an object or array of objects with the following:
+ * * type - (required) the extension point event name. The available extension points include the request extension points as well as the following server extension points:
+ * * * 'onPreStart' - called before the connection listeners are started.
+ * * * 'onPostStart' - called after the connection listeners are started.
+ * * * 'onPreStop' - called before the connection listeners are stopped.
+ * * * 'onPostStop' - called after the connection listeners are stopped.
+ * * method - (required) a function or an array of functions to be executed at a specified point during request processing. The required extension function signature is:
+ * * * server extension points: async function(server) where:
+ * * * * server - the server object.
+ * * * * this - the object provided via options.bind or the current active context set with server.bind().
+ * * * request extension points: a lifecycle method.
+ * * options - (optional) an object with the following:
+ * * * before - a string or array of strings of plugin names this method must execute before (on the same event). Otherwise, extension methods are executed in the order added.
+ * * * after - a string or array of strings of plugin names this method must execute after (on the same event). Otherwise, extension methods are executed in the order added.
+ * * * bind - a context object passed back to the provided method (via this) when called. Ignored if the method is an arrow function.
+ * * * sandbox - if set to 'plugin' when adding a request extension points the extension is only added to routes defined by the current plugin. Not allowed when configuring route-level extensions, or
+ *     when adding server extensions. Defaults to 'server' which applies to any route added to the server the extension is added to.
+ * @return void
+ */
+export interface ServerExtEventsObject<A = ServerApplicationState> {
+    /**
+     * (required) the extension point event name. The available extension points include the request extension points as well as the following server extension points:
+     * * 'onPreStart' - called before the connection listeners are started.
+     * * 'onPostStart' - called after the connection listeners are started.
+     * * 'onPreStop' - called before the connection listeners are stopped.
+     */
+    type: ServerExtType;
+    /**
+     * (required) a function or an array of functions to be executed at a specified point during request processing. The required extension function signature is:
+     * * server extension points: async function(server) where:
+     * * * server - the server object.
+     * * * this - the object provided via options.bind or the current active context set with server.bind().
+     * * request extension points: a lifecycle method.
+     */
+    method: ServerExtPointFunction<A> | ServerExtPointFunction<A>[];
+    options?: ServerExtOptions | undefined;
+}
+
+export interface RouteExtObject<Refs extends ReqRef = ReqRefDefaults> {
+    method: Lifecycle.Method<Refs>;
+    options?: ServerExtOptions | undefined;
+}
+
+/**
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevents)
+ * Registers an extension function in one of the request lifecycle extension points where:
+ * @param events - an object or array of objects with the following:
+ * * type - (required) the extension point event name. The available extension points include the request extension points as well as the following server extension points:
+ * * * 'onPreStart' - called before the connection listeners are started.
+ * * * 'onPostStart' - called after the connection listeners are started.
+ * * * 'onPreStop' - called before the connection listeners are stopped.
+ * * * 'onPostStop' - called after the connection listeners are stopped.
+ * * method - (required) a function or an array of functions to be executed at a specified point during request processing. The required extension function signature is:
+ * * * server extension points: async function(server) where:
+ * * * * server - the server object.
+ * * * * this - the object provided via options.bind or the current active context set with server.bind().
+ * * * request extension points: a lifecycle method.
+ * * options - (optional) an object with the following:
+ * * * before - a string or array of strings of plugin names this method must execute before (on the same event). Otherwise, extension methods are executed in the order added.
+ * * * after - a string or array of strings of plugin names this method must execute after (on the same event). Otherwise, extension methods are executed in the order added.
+ * * * bind - a context object passed back to the provided method (via this) when called. Ignored if the method is an arrow function.
+ * * * sandbox - if set to 'plugin' when adding a request extension points the extension is only added to routes defined by the current plugin. Not allowed when configuring route-level extensions, or
+ *     when adding server extensions. Defaults to 'server' which applies to any route added to the server the extension is added to.
+ * @return void
+ */
+export interface ServerExtEventsRequestObject {
+    /**
+     * (required) the extension point event name. The available extension points include the request extension points as well as the following server extension points:
+     * * 'onPreStart' - called before the connection listeners are started.
+     * * 'onPostStart' - called after the connection listeners are started.
+     * * 'onPreStop' - called before the connection listeners are stopped.
+     * * 'onPostStop' - called after the connection listeners are stopped.
+     */
+    type: ServerRequestExtType;
+    /**
+     * (required) a function or an array of functions to be executed at a specified point during request processing. The required extension function signature is:
+     * * server extension points: async function(server) where:
+     * * * server - the server object.
+     * * * this - the object provided via options.bind or the current active context set with server.bind().
+     * * request extension points: a lifecycle method.
+     */
+    method: Lifecycle.Method | Lifecycle.Method[];
+    /**
+     * (optional) an object with the following:
+     * * before - a string or array of strings of plugin names this method must execute before (on the same event). Otherwise, extension methods are executed in the order added.
+     * * after - a string or array of strings of plugin names this method must execute after (on the same event). Otherwise, extension methods are executed in the order added.
+     * * bind - a context object passed back to the provided method (via this) when called. Ignored if the method is an arrow function.
+     * * sandbox - if set to 'plugin' when adding a request extension points the extension is only added to routes defined by the current plugin. Not allowed when configuring route-level extensions,
+     * or when adding server extensions. Defaults to 'server' which applies to any route added to the server the extension is added to.
+     */
+    options?: ServerExtOptions | undefined;
+}
+
+export type ServerExtPointFunction<A = ServerApplicationState> = (server: Server<A>) => void;
+
+/**
+ * An object with the following:
+ * * before - a string or array of strings of plugin names this method must execute before (on the same event). Otherwise, extension methods are executed in the order added.
+ * * after - a string or array of strings of plugin names this method must execute after (on the same event). Otherwise, extension methods are executed in the order added.
+ * * bind - a context object passed back to the provided method (via this) when called. Ignored if the method is an arrow function.
+ * * sandbox - if set to 'plugin' when adding a request extension points the extension is only added to routes defined by the current plugin. Not allowed when configuring route-level extensions, or
+ * when adding server extensions. Defaults to 'server' which applies to any route added to the server the extension is added to. For context [See
+ * docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevents)
+ */
+export interface ServerExtOptions {
+    /**
+     * a string or array of strings of plugin names this method must execute before (on the same event). Otherwise, extension methods are executed in the order added.
+     */
+    before?: string | string[] | undefined;
+    /**
+     * a string or array of strings of plugin names this method must execute after (on the same event). Otherwise, extension methods are executed in the order added.
+     */
+    after?: string | string[] | undefined;
+    /**
+     * a context object passed back to the provided method (via this) when called. Ignored if the method is an arrow function.
+     */
+    bind?: object | undefined;
+    /**
+     * if set to 'plugin' when adding a request extension points the extension is only added to routes defined by the current plugin. Not allowed when configuring route-level extensions, or when
+     * adding server extensions. Defaults to 'server' which applies to any route added to the server the extension is added to.
+     */
+    sandbox?: 'server' | 'plugin' | undefined;
+}

package/lib/types/server/index.d.ts

@@ -0,0 +1,11 @@
+export * from './auth';
+export * from './cache';
+export * from './encoders';
+export * from './events';
+export * from './ext';
+export * from './info';
+export * from './inject';
+export * from './methods';
+export * from './options';
+export * from './server';
+export * from './state';

package/lib/types/server/info.d.ts

@@ -0,0 +1,53 @@
+/**
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverinfo)
+ * An object containing information about the server where:
+ */
+export interface ServerInfo {
+    /**
+     * a unique server identifier (using the format '{hostname}:{pid}:{now base36}').
+     */
+    id: string;
+
+    /**
+     * server creation timestamp.
+     */
+    created: number;
+
+    /**
+     * server start timestamp (0 when stopped).
+     */
+    started: number;
+
+    /**
+     * the connection [port](https://github.com/hapijs/hapi/blob/master/API.md#server.options.port) based on the following rules:
+     *  * before the server has been started: the configured port value.
+     *  * after the server has been started: the actual port assigned when no port is configured or was set to 0.
+     */
+    port: number | string;
+
+    /**
+     * The [host](https://github.com/hapijs/hapi/blob/master/API.md#server.options.host) configuration value.
+     */
+    host: string;
+
+    /**
+     * the active IP address the connection was bound to after starting. Set to undefined until the server has been
+     * started or when using a non TCP port (e.g. UNIX domain socket).
+     */
+    address: undefined | string;
+
+    /**
+     *  the protocol used:
+     * * 'http' - HTTP.
+     * * 'https' - HTTPS.
+     * * 'socket' - UNIX domain socket or Windows named pipe.
+     */
+    protocol: 'http' | 'https' | 'socket';
+
+    /**
+     * a string representing the connection (e.g. 'http://example.com:8080' or 'socket:/unix/domain/socket/path'). Contains
+     * the uri value if set, otherwise constructed from the available settings. If no port is configured or is set
+     * to 0, the uri will not include a port component until the server is started.
+     */
+    uri: string;
+}

package/lib/types/server/inject.d.ts

@@ -0,0 +1,89 @@
+import { RequestOptions as ShotRequestOptions, ResponseObject as ShotResponseObject } from '@hapi/shot';
+import { PluginsStates } from '../plugin';
+import { AuthArtifacts, AuthCredentials, Request, RequestApplicationState } from '../request';
+
+/**
+ * An object with:
+ * * method - (optional) the request HTTP method (e.g. 'POST'). Defaults to 'GET'.
+ * * url - (required) the request URL. If the URI includes an authority (e.g. 'example.com:8080'), it is used to automatically set an HTTP 'Host' header, unless one was specified in headers.
+ * * headers - (optional) an object with optional request headers where each key is the header name and the value is the header content. Defaults to no additions to the default shot headers.
+ * * payload - (optional) an string, buffer or object containing the request payload. In case of an object it will be converted to a string for you. Defaults to no payload. Note that payload
+ * processing defaults to 'application/json' if no 'Content-Type' header provided.
+ * * credentials - (optional) an credentials object containing authentication information. The credentials are used to bypass the default authentication strategies, and are validated directly as if
+ * they were received via an authentication scheme. Defaults to no credentials.
+ * * artifacts - (optional) an artifacts object containing authentication artifact information. The artifacts are used to bypass the default authentication strategies, and are validated directly as
+ * if they were received via an authentication scheme. Ignored if set without credentials. Defaults to no artifacts.
+ * * app - (optional) sets the initial value of request.app, defaults to {}.
+ * * plugins - (optional) sets the initial value of request.plugins, defaults to {}.
+ * * allowInternals - (optional) allows access to routes with config.isInternal set to true. Defaults to false.
+ * * remoteAddress - (optional) sets the remote address for the incoming connection.
+ * * simulate - (optional) an object with options used to simulate client request stream conditions for testing:
+ * * error - if true, emits an 'error' event after payload transmission (if any). Defaults to false.
+ * * close - if true, emits a 'close' event after payload transmission (if any). Defaults to false.
+ * * end - if false, does not end the stream. Defaults to true.
+ * * split - indicates whether the request payload will be split into chunks. Defaults to undefined, meaning payload will not be chunked.
+ * * validate - (optional) if false, the options inputs are not validated. This is recommended for run-time usage of inject() to make it perform faster where input validation can be tested
+ * separately.
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverinjectoptions)
+ * For context [Shot module](https://github.com/hapijs/shot)
+ */
+export interface ServerInjectOptions extends ShotRequestOptions {
+    /**
+     * Authentication bypass options.
+     */
+    auth?: {
+        /**
+         * The authentication strategy name matching the provided credentials.
+         */
+        strategy: string;
+        /**
+         * The credentials are used to bypass the default authentication strategies,
+         * and are validated directly as if they were received via an authentication scheme.
+         */
+        credentials: AuthCredentials;
+        /**
+         * The artifacts are used to bypass the default authentication strategies,
+         * and are validated directly as if they were received via an authentication scheme. Defaults to no artifacts.
+         */
+        artifacts?: AuthArtifacts | undefined;
+    } | undefined;
+    /**
+     * sets the initial value of request.app, defaults to {}.
+     */
+    app?: RequestApplicationState | undefined;
+    /**
+     * sets the initial value of request.plugins, defaults to {}.
+     */
+    plugins?: PluginsStates | undefined;
+    /**
+     * allows access to routes with config.isInternal set to true. Defaults to false.
+     */
+    allowInternals?: boolean | undefined;
+}
+
+/**
+ * A response object with the following properties:
+ * * statusCode - the HTTP status code.
+ * * headers - an object containing the headers set.
+ * * payload - the response payload string.
+ * * rawPayload - the raw response payload buffer.
+ * * raw - an object with the injection request and response objects:
+ * * req - the simulated node request object.
+ * * res - the simulated node response object.
+ * * result - the raw handler response (e.g. when not a stream or a view) before it is serialized for transmission. If not available, the value is set to payload. Useful for inspection and reuse of
+ * the internal objects returned (instead of parsing the response string).
+ * * request - the request object.
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverinjectoptions)
+ * For context [Shot module](https://github.com/hapijs/shot)
+ */
+export interface ServerInjectResponse<Result = object> extends ShotResponseObject {
+    /**
+     * the raw handler response (e.g. when not a stream or a view) before it is serialized for transmission. If not available, the value is set to payload. Useful for inspection and reuse of the
+     * internal objects returned (instead of parsing the response string).
+     */
+    result: Result | undefined;
+    /**
+     * the request object.
+     */
+    request: Request;
+}

package/lib/types/server/methods.d.ts

@@ -0,0 +1,95 @@
+import { CacheStatisticsObject, PolicyOptions } from "@hapi/catbox";
+
+type AnyMethod = (...args: any[]) => any;
+
+export type CachedServerMethod<T extends AnyMethod> = T & {
+    cache?: {
+        drop(...args: Parameters<T>): Promise<void>;
+        stats: CacheStatisticsObject
+    }
+};
+
+/**
+ * The method function with a signature async function(...args, [flags]) where:
+ * * ...args - the method function arguments (can be any number of arguments or none).
+ * * flags - when caching is enabled, an object used to set optional method result flags:
+ * * * ttl - 0 if result is valid but cannot be cached. Defaults to cache policy.
+ * For reference [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodname-method-options)
+ */
+export type ServerMethod = AnyMethod;
+
+/**
+ * The same cache configuration used in server.cache().
+ * The generateTimeout option is required.
+ * For reference [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodname-method-options)
+ * For reference [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servercacheoptions)
+ */
+export interface ServerMethodCache extends PolicyOptions<any> {
+    generateTimeout: number | false;
+    cache?: string;
+    segment?: string;
+}
+
+/**
+ * Configuration object:
+ * * bind - a context object passed back to the method function (via this) when called. Defaults to active context (set via server.bind() when the method is registered. Ignored if the method is an
+ * arrow function.
+ * * cache - the same cache configuration used in server.cache(). The generateTimeout option is required.
+ * * generateKey - a function used to generate a unique key (for caching) from the arguments passed to the method function (the flags argument is not passed as input). The server will automatically
+ * generate a unique key if the function's arguments are all of types 'string', 'number', or 'boolean'. However if the method uses other types of arguments, a key generation function must be provided
+ * which takes the same arguments as the function and returns a unique string (or null if no key can be generated). For reference [See
+ * docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodname-method-options)
+ */
+export interface ServerMethodOptions {
+    /**
+     * a context object passed back to the method function (via this) when called. Defaults to active context (set via server.bind() when the method is registered. Ignored if the method is an arrow
+     * function.
+     */
+    bind?: object | undefined;
+    /**
+     * the same cache configuration used in server.cache(). The generateTimeout option is required.
+     */
+    cache?: ServerMethodCache | undefined;
+    /**
+     * a function used to generate a unique key (for caching) from the arguments passed to the method function (the flags argument is not passed as input). The server will automatically generate a
+     * unique key if the function's arguments are all of types 'string', 'number', or 'boolean'. However if the method uses other types of arguments, a key generation function must be provided which
+     * takes the same arguments as the function and returns a unique string (or null if no key can be generated).
+     */
+    generateKey?(...args: any[]): string | null;
+}
+
+/**
+ * An object or an array of objects where each one contains:
+ * * name - the method name.
+ * * method - the method function.
+ * * options - (optional) settings.
+ * For reference [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodmethods)
+ */
+export interface ServerMethodConfigurationObject {
+    /**
+     * the method name.
+     */
+    name: string;
+    /**
+     * the method function.
+     */
+    method: ServerMethod;
+    /**
+     * (optional) settings.
+     */
+    options?: ServerMethodOptions | undefined;
+}
+
+interface BaseServerMethods {
+    [name: string]: (
+        ServerMethod |
+        CachedServerMethod<ServerMethod> |
+        BaseServerMethods
+    );
+}
+
+/**
+ * An empty interface to allow typings of custom server.methods.
+ */
+export interface ServerMethods extends BaseServerMethods {
+}

package/lib/types/server/options.d.ts

@@ -0,0 +1,235 @@
+import * as http from 'http';
+import * as https from 'https';
+
+import { MimosOptions } from '@hapi/mimos';
+
+import { PluginSpecificConfiguration } from '../plugin';
+import { RouteOptions } from '../route';
+import { CacheProvider, ServerOptionsCache } from './cache';
+import { SameSitePolicy, ServerStateCookieOptions } from './state';
+
+export interface ServerOptionsCompression {
+    minBytes: number;
+}
+
+/**
+ * Empty interface to allow for custom augmentation.
+ */
+
+export interface ServerOptionsApp {
+}
+
+/**
+ * The server options control the behavior of the server object. Note that the options object is deeply cloned
+ * (with the exception of listener which is shallowly copied) and should not contain any values that are unsafe to perform deep copy on.
+ * All options are optionals.
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-server-options)
+ */
+export interface ServerOptions {
+    /**
+     * @default '0.0.0.0' (all available network interfaces).
+     * Sets the hostname or IP address the server will listen on. If not configured, defaults to host if present, otherwise to all available network interfaces. Set to '127.0.0.1' or 'localhost' to
+     * restrict the server to only those coming from the same host.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionsaddress)
+     */
+    address?: string | undefined;
+
+    /**
+     * @default {}.
+     * Provides application-specific configuration which can later be accessed via server.settings.app. The framework does not interact with this object. It is simply a reference made available
+     * anywhere a server reference is provided. Note the difference between server.settings.app which is used to store static configuration values and server.app which is meant for storing run-time
+     * state.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionsapp)
+     */
+    app?: ServerOptionsApp | undefined;
+
+    /**
+     * @default true.
+     * Used to disable the automatic initialization of the listener. When false, indicates that the listener will be started manually outside the framework.
+     * Cannot be set to true along with a port value.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionsautolisten)
+     */
+    autoListen?: boolean | undefined;
+
+    /**
+     * @default { engine: require('@hapi/catbox-memory' }.
+     * Sets up server-side caching providers. Every server includes a default cache for storing application state. By default, a simple memory-based cache is created which has limited capacity and
+     * capabilities. hapi uses catbox for its cache implementation which includes support for common storage solutions (e.g. Redis, MongoDB, Memcached, Riak, among others). Caching is only utilized
+     * if methods and plugins explicitly store their state in the cache. The server cache configuration only defines the storage container itself. The configuration can be assigned one or more
+     * (array):
+     * * a class or prototype function (usually obtained by calling require() on a catbox strategy such as require('@hapi/catbox-redis')). A new catbox client will be created internally using this
+     * function.
+     * * a configuration object with the following:
+     * * * engine - a class, a prototype function, or a catbox engine object.
+     * * * name - an identifier used later when provisioning or configuring caching for server methods or plugins. Each cache name must be unique. A single item may omit the name option which defines
+     * the default cache. If every cache includes a name, a default memory cache is provisioned as well.
+     * * * shared - if true, allows multiple cache users to share the same segment (e.g. multiple methods using the same cache storage container). Default to false.
+     * * * partition - (optional) string used to isolate cached data. Defaults to 'hapi-cache'.
+     * * * other options passed to the catbox strategy used. Other options are only passed to catbox when engine above is a class or function and ignored if engine is a catbox engine object).
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionscache)
+     */
+    cache?: CacheProvider | ServerOptionsCache | ServerOptionsCache[] | undefined;
+
+    /**
+     * @default { minBytes: 1024 }.
+     * Defines server handling of content encoding requests. If false, response content encoding is disabled and no compression is performed by the server.
+     */
+    compression?: boolean | ServerOptionsCompression | undefined;
+
+    /**
+     * @default { request: ['implementation'] }.
+     * Determines which logged events are sent to the console. This should only be used for development and does not affect which events are actually logged internally and recorded. Set to false to
+     * disable all console logging, or to an object with:
+     * * log - a string array of server log tags to be displayed via console.error() when the events are logged via server.log() as well as internally generated server logs. Defaults to no output.
+     * * request - a string array of request log tags to be displayed via console.error() when the events are logged via request.log() as well as internally generated request logs. For example, to
+     * display all errors, set the option to ['error']. To turn off all console debug messages set it to false. To display all request logs, set it to '*'. Defaults to uncaught errors thrown in
+     * external code (these errors are handled automatically and result in an Internal Server Error response) or runtime errors due to developer error. For example, to display all errors, set the log
+     * or request to ['error']. To turn off all output set the log or request to false. To display all server logs, set the log or request to '*'. To disable all debug information, set debug to
+     * false.
+     */
+    debug?: false | {
+        log?: string | string[] | false | undefined;
+        request?: string | string[] | false | undefined;
+    } | undefined;
+
+    /**
+     * @default the operating system hostname and if not available, to 'localhost'.
+     * The public hostname or IP address. Used to set server.info.host and server.info.uri and as address is none provided.
+     */
+    host?: string | undefined;
+
+    info?: {
+        /**
+         * @default false.
+         * If true, the request.info.remoteAddress and request.info.remotePort are populated when the request is received which can consume more resource (but is ok if the information is needed,
+         * especially for aborted requests). When false, the fields are only populated upon demand (but will be undefined if accessed after the request is aborted).
+         */
+        remote?: boolean | undefined;
+    } | undefined;
+
+    /**
+     * @default none.
+     * An optional node HTTP (or HTTPS) http.Server object (or an object with a compatible interface).
+     * If the listener needs to be manually started, set autoListen to false.
+     * If the listener uses TLS, set tls to true.
+     */
+    listener?: http.Server | undefined;
+
+    /**
+     * @default { sampleInterval: 0 }.
+     * Server excessive load handling limits where:
+     * * sampleInterval - the frequency of sampling in milliseconds. When set to 0, the other load options are ignored. Defaults to 0 (no sampling).
+     * * maxHeapUsedBytes - maximum V8 heap size over which incoming requests are rejected with an HTTP Server Timeout (503) response. Defaults to 0 (no limit).
+     * * maxRssBytes - maximum process RSS size over which incoming requests are rejected with an HTTP Server Timeout (503) response. Defaults to 0 (no limit).
+     * * maxEventLoopDelay - maximum event loop delay duration in milliseconds over which incoming requests are rejected with an HTTP Server Timeout (503) response. Defaults to 0 (no limit).
+     */
+    load?: {
+        /** the frequency of sampling in milliseconds. When set to 0, the other load options are ignored. Defaults to 0 (no sampling). */
+        sampleInterval?: number | undefined;
+
+        /** maximum V8 heap size over which incoming requests are rejected with an HTTP Server Timeout (503) response. Defaults to 0 (no limit). */
+        maxHeapUsedBytes?: number | undefined;
+        /**
+         * maximum process RSS size over which incoming requests are rejected with an HTTP Server Timeout (503) response. Defaults to 0 (no limit).
+         */
+        maxRssBytes?: number | undefined;
+        /**
+         * maximum event loop delay duration in milliseconds over which incoming requests are rejected with an HTTP Server Timeout (503) response.
+         * Defaults to 0 (no limit).
+         */
+        maxEventLoopDelay?: number | undefined;
+    } | undefined;
+
+    /**
+     * @default none.
+     * Options passed to the mimos module when generating the mime database used by the server (and accessed via server.mime):
+     * * override - an object hash that is merged into the built in mime information specified here. Each key value pair represents a single mime object. Each override value must contain:
+     * * key - the lower-cased mime-type string (e.g. 'application/javascript').
+     * * value - an object following the specifications outlined here. Additional values include:
+     * * * type - specify the type value of result objects, defaults to key.
+     * * * predicate - method with signature function(mime) when this mime type is found in the database, this function will execute to allows customizations.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionsmime)
+     */
+    mime?: MimosOptions | undefined;
+
+    /**
+     * @default { cleanStop: true }
+     * Defines server handling of server operations.
+     */
+    operations?: {
+        /**
+         * @default true
+         * If true, the server keeps track of open connections and properly closes them when the server is stopped.
+         * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptionsoperations)
+         */
+        cleanStop?: boolean;
+    }
+
+    /**
+     * @default {}.
+     * Plugin-specific configuration which can later be accessed via server.settings.plugins. plugins is an object where each key is a plugin name and the value is the configuration. Note the
+     * difference between server.settings.plugins which is used to store static configuration values and server.plugins which is meant for storing run-time state.
+     */
+    plugins?: PluginSpecificConfiguration | undefined;
+
+    /**
+     * @default 0 (an ephemeral port).
+     * The TCP port the server will listen to. Defaults the next available port when the server is started (and assigned to server.info.port).
+     * If port is a string containing a '/' character, it is used as a UNIX domain socket path. If it starts with '\.\pipe', it is used as a Windows named pipe.
+     */
+    port?: number | string | undefined;
+
+    /**
+     * @default { isCaseSensitive: true, stripTrailingSlash: false }.
+     * Controls how incoming request URIs are matched against the routing table:
+     * * isCaseSensitive - determines whether the paths '/example' and '/EXAMPLE' are considered different resources. Defaults to true.
+     * * stripTrailingSlash - removes trailing slashes on incoming paths. Defaults to false.
+     */
+    router?: {
+        isCaseSensitive?: boolean | undefined;
+        stripTrailingSlash?: boolean | undefined;
+    } | undefined;
+
+    /**
+     * @default none.
+     * A route options object used as the default configuration for every route.
+     */
+    routes?: RouteOptions | undefined;
+
+    /**
+     * Default value:
+     * {
+     *     strictHeader: true,
+     *     ignoreErrors: false,
+     *     isSecure: true,
+     *     isHttpOnly: true,
+     *     isSameSite: 'Strict',
+     *     encoding: 'none'
+     * }
+     * Sets the default configuration for every state (cookie) set explicitly via server.state() or implicitly (without definition) using the state configuration object.
+     */
+    state?: ServerStateCookieOptions | undefined;
+
+    /**
+     * @default none.
+     * Used to create an HTTPS connection. The tls object is passed unchanged to the node HTTPS server as described in the node HTTPS documentation.
+     */
+    tls?: boolean | https.ServerOptions | undefined;
+
+    /**
+     * @default constructed from runtime server information.
+     * The full public URI without the path (e.g. 'http://example.com:8080'). If present, used as the server server.info.uri, otherwise constructed from the server settings.
+     */
+    uri?: string | undefined;
+
+    /**
+     * Query parameter configuration.
+     */
+    query?: {
+        /**
+         * the method must return an object where each key is a parameter and matching value is the parameter value.
+         * If the method throws, the error is used as the response or returned when `request.setUrl` is called.
+         */
+        parser(raw: Record<string, string>): Record<string, any>;
+    } | undefined;
+}