@types/hapi

constructor

constructor(options?: ServerOptions);

• Creates a new server object

  Parameter options

  server configuration object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serveroptions)

property app

app: ApplicationState;

• Provides a safe place to store server-specific run-time application data without potential conflicts with the framework internals. The data can be accessed whenever the server is accessible. Initialized with an empty object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverapp)

property auth

readonly auth: ServerAuth;

• Server Auth: properties and methods

property cache

cache: ServerCache;

• [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servercacheoptions)

property decorations

readonly decorations: { request: string[]; toolkit: string[]; server: string[] };

• Provides access to the decorations already applied to various framework interfaces. The object must not be modified directly, but only through server.decorate. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverdecorations)

property events

events: ServerEvents;

• Access: podium public interface. The server events emitter. Utilizes the podium with support for event criteria validation, channels, and filters. Use the following methods to interact with server.events: [server.events.emit(criteria, data)](https://github.com/hapijs/hapi/blob/master/API.md#server.events.emit()) - emit server events. [server.events.on(criteria, listener)](https://github.com/hapijs/hapi/blob/master/API.md#server.events.on()) - subscribe to all events. [server.events.once(criteria, listener)](https://github.com/hapijs/hapi/blob/master/API.md#server.events.once()) - subscribe to Other methods include: server.events.removeListener(name, listener), server.events.removeAllListeners(name), and server.events.hasListeners(name). [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverevents)

property info

readonly info: ServerInfo;

• An object containing information about the server where: * id - a unique server identifier (using the format '{hostname}:{pid}:{now base36}'). * created - server creation timestamp. * started - server start timestamp (0 when stopped). * port - the connection port based on the following rules: * host - The host configuration value. * address - 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). * protocol - the protocol used: * 'http' - HTTP. * 'https' - HTTPS. * 'socket' - UNIX domain socket or Windows named pipe. * uri - 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. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverinfo)

property listener

listener: http.Server;

• Access: read only and listener public interface. The node HTTP server object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverlistener)

property load

readonly load: {
    eventLoopDelay: number;
    concurrent: number;
    heapUsed: number;
    rss: number;
};

• An object containing the process load metrics (when load.sampleInterval is enabled): * eventLoopDelay - event loop delay milliseconds. * heapUsed - V8 heap usage. * rss - RSS memory usage. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverload)

property methods

readonly methods: ServerMethods;

• Server methods are functions registered with the server and used throughout the application as a common utility. Their advantage is in the ability to configure them to use the built-in cache and share across multiple request handlers without having to create a common module. sever.methods is an object which provides access to the methods registered via server.method() where each server method name is an object property. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethods

property mime

mime: any;

• Provides access to the server MIME database used for setting content-type information. The object must not be modified directly but only through the [mime](https://github.com/hapijs/hapi/blob/master/API.md#server.options.mime) server setting. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermime)

property plugins

plugins: PluginProperties;

• An object containing the values exposed by each registered plugin where each key is a plugin name and the values are the exposed properties by each plugin using server.expose(). Plugins may set the value of the server.plugins[name] object directly or via the server.expose() method. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverplugins)

property realm

readonly realm: ServerRealm;

• The realm object contains sandboxed server settings specific to each plugin or authentication strategy. When registering a plugin or an authentication scheme, a server object reference is provided with a new server.realm container specific to that registration. It allows each plugin to maintain its own settings without leaking and affecting other plugins. For example, a plugin can set a default file path for local resources without breaking other plugins' configured paths. When calling server.bind(), the active realm's settings.bind property is set which is then used by routes and extensions added at the same level (server root or plugin). [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverrealm)

property registrations

readonly registrations: PluginsListRegistered;

• An object of the currently registered plugins where each key is a registered plugin name and the value is an object containing: * version - the plugin version. * name - the plugin name. * options - (optional) options passed to the plugin during registration. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverregistrations)

property settings

readonly settings: ServerOptions;

• The server configuration object after defaults applied. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serversettings)

property states

readonly states: ServerState;

• The server cookies manager. Access: read only and statehood public interface. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverstates)

property type

readonly type: 'socket' | 'tcp';

• A string indicating the listener type where: * 'socket' - UNIX domain socket or Windows named pipe. * 'tcp' - an HTTP listener.

property version

readonly version: string;

• The hapi module version number.

method bind

bind: (context: object) => void;

• Sets a global context used as the default bind object when adding a route or an extension where:

  Parameter context

  the object used to bind this in lifecycle methods such as the route handler and extension methods. The context is also made available as h.context. Return value: none. When setting a context inside a plugin, the context is applied only to methods set up by the plugin. Note that the context applies only to routes and extensions added after it has been set. Ignored if the method being bound is an arrow function. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverbindcontext)

method control

control: (server: Server) => void;

• Links another server to the initialize/start/stop state of the current server by calling the controlled server initialize()/start()/stop() methods whenever the current server methods are called, where:

method decoder

decoder: (
    encoding: string,
    decoder: (options: PayloadCompressionDecoderSettings) => zlib.Gunzip
) => void;

• Registers a custom content decoding compressor to extend the built-in support for 'gzip' and 'deflate' where:

  Parameter encoding

  the decoder name string.

  Parameter decoder

  a function using the signature function(options) where options are the encoding specific options configured in the route payload.compression configuration option, and the return value is an object compatible with the output of node's zlib.createGunzip(). Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverdecoderencoding-decoder)

method decorate

decorate: {
    (
        type: 'handler',
        property: DecorateName,
        method: HandlerDecorationMethod,
        options?: { apply?: boolean | undefined; extend?: boolean | undefined }
    ): void;
    (
        type: 'request',
        property: DecorateName,
        method: (
            existing: (...args: any[]) => any
        ) => (request: Request) => DecorationMethod<Request>,
        options: { apply: true; extend: true }
    ): void;
    (
        type: 'request',
        property: DecorateName,
        method: (request: Request) => DecorationMethod<Request>,
        options: { apply: true; extend?: boolean }
    ): void;
    (
        type: 'request',
        property: DecorateName,
        method: DecorationMethod<Request>,
        options?: { apply?: boolean; extend?: boolean }
    ): void;
    (
        type: 'toolkit',
        property: DecorateName,
        method: (
            existing: (...args: any[]) => any
        ) => DecorationMethod<ResponseToolkit>,
        options: { apply?: boolean; extend: true }
    ): void;
    (
        type: 'toolkit',
        property: DecorateName,
        method: DecorationMethod<ResponseToolkit>,
        options?: { apply?: boolean; extend?: boolean }
    ): void;
    (
        type: 'server',
        property: DecorateName,
        method: (existing: (...args: any[]) => any) => DecorationMethod<Server>,
        options: { apply?: boolean; extend: true }
    ): void;
    (
        type: 'server',
        property: DecorateName,
        method: DecorationMethod<Server>,
        options?: { apply?: boolean; extend?: boolean }
    ): void;
};

• Extends various framework interfaces with custom methods where:

  Parameter type

  the interface being decorated. Supported types: 'handler' - adds a new handler type to be used in routes handlers. 'request' - adds methods to the Request object. 'server' - adds methods to the Server object. 'toolkit' - adds methods to the response toolkit.

  Parameter property

  the object decoration key name.

  Parameter method

  the extension function or other value.

  Parameter options

  (optional) supports the following optional settings: apply - when the type is 'request', if true, the method function is invoked using the signature function(request) where request is the current request object and the returned value is assigned as the decoration. extend - if true, overrides an existing decoration. The method must be a function with the signature function(existing) where: existing - is the previously set decoration method value. must return the new decoration function or value. cannot be used to extend handler decorations. void; [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverdecoratetype-property-method-options)

method dependency

dependency: (
    dependencies: Dependencies,
    after?: (server: Server) => Promise<void>
) => void;

• Used within a plugin to declare a required dependency on other plugins where:

  Parameter dependencies

  plugins which must be registered in order for this plugin to operate. Plugins listed must be registered before the server is initialized or started.

  Parameter after

  (optional) a function that is called after all the specified dependencies have been registered and before the server starts. The function is only called if the server is initialized or started. The function signature is async function(server) where: server - the server the dependency() method was called on. Return value: none. The after method is identical to setting a server extension point on 'onPreStart'. If a circular dependency is detected, an exception is thrown (e.g. two plugins each has an after function to be called after the other). The method does not provide version dependency which should be implemented using npm peer dependencies. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverdependencydependencies-after)

method encoder

encoder: (
    encoding: string,
    encoder: (options: RouteCompressionEncoderSettings) => zlib.Gzip
) => void;

• Registers a custom content encoding compressor to extend the built-in support for 'gzip' and 'deflate' where:

  Parameter encoding

  the encoder name string.

  Parameter encoder

  a function using the signature function(options) where options are the encoding specific options configured in the route compression option, and the return value is an object compatible with the output of node's zlib.createGzip(). Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverencoderencoding-encoder)

method event

event: (events: ServerEventsApplication | ServerEventsApplication[]) => void;

• Register custom application events where:

  Parameter events

  must be one of: * an event name string. * an event options object with the following optional keys (unless noted otherwise): * * name - the event name string (required). * * channels - a string or array of strings specifying the event channels available. Defaults to no channel restrictions (event updates can specify a channel or not). * * clone - if true, the data object passed to server.events.emit() is cloned before it is passed to the listeners (unless an override specified by each listener). Defaults to false (data is passed as-is). * * spread - if true, the data object passed to server.event.emit() must be an array and the listener method is called with each array element passed as a separate argument (unless an override specified by each listener). This should only be used when the emitted data structure is known and predictable. Defaults to false (data is emitted as a single argument regardless of its type). * * tags - if true and the criteria object passed to server.event.emit() includes tags, the tags are mapped to an object (where each tag string is the key and the value is true) which is appended to the arguments list at the end. A configuration override can be set by each listener. Defaults to false. * * shared - if true, the same event name can be registered multiple times where the second registration is ignored. Note that if the registration config is changed between registrations, only the first configuration is used. Defaults to false (a duplicate registration will throw an error). * a podium emitter object. * an array containing any of the above. Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverevents)

method expose

expose: { (key: string, value: any): void; (obj: object): void };

• Used within a plugin to expose a property via server.plugins[name] where:

  Parameter key

  the key assigned (server.plugins[name][key]).

  Parameter value

  the value assigned. Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverexposekey-value)

• Merges an object into to the existing content of server.plugins[name] where:

  Parameter obj

  the object merged into the exposed properties container. Return value: none. Note that all the properties of obj are deeply cloned into server.plugins[name], so avoid using this method for exposing large objects that may be expensive to clone or singleton objects such as database client objects. Instead favor server.expose(key, value), which only copies a reference to value. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverexposeobj)

method ext

ext: {
    (
        events:
            | ServerExtEventsObject
            | ServerExtEventsObject[]
            | ServerExtEventsRequestObject
            | ServerExtEventsRequestObject[]
    ): void;
    (
        event: ServerExtType,
        method: ServerExtPointFunction,
        options?: ServerExtOptions
    ): void;
    (
        event: ServerRequestExtType,
        method: Lifecycle.Method,
        options?: ServerExtOptions
    ): void;
};

• Registers an extension function in one of the request lifecycle extension points where:

  Parameter 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. void [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevents)

• Registers a single extension event using the same properties as used in server.ext(events), but passed as arguments. Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverextevent-method-options)

method initialize

initialize: () => Promise<void>;

• Initializes the server (starts the caches, finalizes plugin registration) but does not start listening on the connection port. Return value: none. Note that if the method fails and throws an error, the server is considered to be in an undefined state and should be shut down. In most cases it would be impossible to fully recover as the various plugins, caches, and other event listeners will get confused by repeated attempts to start the server or make assumptions about the healthy state of the environment. It is recommended to abort the process when the server fails to start properly. If you must try to resume after an error, call server.stop() first to reset the server state. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverinitialize)

method inject

inject: (options: string | ServerInjectOptions) => Promise<ServerInjectResponse>;

• Injects a request into the server simulating an incoming HTTP request without making an actual socket connection. Injection is useful for testing purposes as well as for invoking routing logic internally without the overhead and limitations of the network stack. The method utilizes the shot module for performing injections, with some additional options and response properties:

  Parameter options

  can be assigned a string with the requested URI, or 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. Return value: 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. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverinjectoptions)

method log

log: (
    tags: string | string[],
    data?: string | object | (() => any),
    timestamp?: number
) => void;

• Logs server events that cannot be associated with a specific request. When called the server emits a 'log' event which can be used by other listeners or plugins to record the information or output to the console. The arguments are:

  Parameter tags

  (required) a string or an array of strings (e.g. ['error', 'database', 'read']) used to identify the event. Tags are used instead of log levels and provide a much more expressive mechanism for describing and filtering events. Any logs generated by the server internally include the 'hapi' tag along with event-specific information.

  Parameter data

  (optional) an message string or object with the application data being logged. If data is a function, the function signature is function() and it called once to generate (return value) the actual data emitted to the listeners. If no listeners match the event, the data function is not invoked.

  Parameter timestamp

  (optional) an timestamp expressed in milliseconds. Defaults to Date.now() (now). Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverlogtags-data-timestamp)

method lookup

lookup: (id: string) => RequestRoute | null;

• Looks up a route configuration where:

  Parameter id

  the route identifier. Return value: the route information if found, otherwise null. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverlookupid)

method match

match: (
    method: Util.HTTP_METHODS,
    path: string,
    host?: string
) => RequestRoute | null;

• Looks up a route configuration where:

  Parameter method

  the HTTP method (e.g. 'GET', 'POST').

  Parameter path

  the requested path (must begin with '/').

  Parameter host

  (optional) hostname (to match against routes with vhost). Return value: the route information if found, otherwise null. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermatchmethod-path-host)

method method

method: {
    (name: string, method: ServerMethod, options?: ServerMethodOptions): void;
    (
        methods:
            | ServerMethodConfigurationObject
            | ServerMethodConfigurationObject[]
    ): void;
};

• Registers a server method where:

  Parameter name

  a unique method name used to invoke the method via server.methods[name].

  Parameter method

  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.

  Parameter options

  (optional) 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). Return value: none. Method names can be nested (e.g. utils.users.get) which will automatically create the full path under server.methods (e.g. accessed via server.methods.utils.users.get). When configured with caching enabled, server.methods[name].cache is assigned an object with the following properties and methods: - await drop(...args) - a function that can be used to clear the cache for a given key. - stats - an object with cache statistics, see catbox for stats documentation. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodname-method-options)

• Registers a server method function as described in server.method() using a configuration object where:

  Parameter methods

  an object or an array of objects where each one contains: * name - the method name. * method - the method function. * options - (optional) settings. Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servermethodmethods)

method path

path: (relativeTo: string) => void;

• Sets the path prefix used to locate static resources (files and view templates) when relative paths are used where:

  Parameter relativeTo

  the path prefix added to any relative file path starting with '.'. Return value: none. Note that setting a path within a plugin only applies to resources accessed by plugin methods. If no path is set, the server default route configuration files.relativeTo settings is used. The path only applies to routes added after it has been set. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverpathrelativeto)

method register

register: {
    <T>(
        plugin: ServerRegisterPluginObject<T>,
        options?: ServerRegisterOptions
    ): Promise<void>;
    <T, U, V, W, X, Y, Z>(
        plugins: ServerRegisterPluginObjectArray<T, U, V, W, X, Y, Z>,
        options?: ServerRegisterOptions
    ): Promise<void>;
    (
        plugins: ServerRegisterPluginObject<any>[],
        options?: ServerRegisterOptions
    ): Promise<void>;
    (
        plugins: Plugin<any> | Plugin<any>[],
        options?: ServerRegisterOptions
    ): Promise<void>;
};

• Registers a plugin where:

  Parameter plugins

  one or an array of: * a plugin object. * an object with the following: * * plugin - a plugin object. * * options - (optional) options passed to the plugin during registration. * * once, routes - (optional) plugin-specific registration options as defined below.

  Parameter options

  (optional) registration options (different from the options passed to the registration function): * once - if true, subsequent registrations of the same plugin are skipped without error. Cannot be used with plugin options. Defaults to false. If not set to true, an error will be thrown the second time a plugin is registered on the server. * routes - modifiers applied to each route added by the plugin: * * prefix - string added as prefix to any route path (must begin with '/'). If a plugin registers a child plugin the prefix is passed on to the child or is added in front of the child-specific prefix. * * vhost - virtual host string (or array of strings) applied to every route. The outer-most vhost overrides the any nested configuration. Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverregisterplugins-options)

method route

route: (route: ServerRoute | ServerRoute[]) => void;

• Adds a route where:

  Parameter route

  a route configuration object or an array of configuration objects where each object contains: * path - (required) the absolute path used to match incoming requests (must begin with '/'). Incoming requests are compared to the configured paths based on the server's router configuration. The path can include named parameters enclosed in {} which will be matched against literal values in the request as described in Path parameters. * method - (required) the HTTP method. Typically one of 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', or 'OPTIONS'. Any HTTP method is allowed, except for 'HEAD'. Use '*' to match against any HTTP method (only when an exact match was not found, and any match with a specific method will be given a higher priority over a wildcard match). Can be assigned an array of methods which has the same result as adding the same route with different methods manually. * vhost - (optional) a domain string or an array of domain strings for limiting the route to only requests with a matching host header field. Matching is done against the hostname part of the header only (excluding the port). Defaults to all hosts. * handler - (required when handler is not set) the route handler function called to generate the response after successful authentication and validation. * options - additional route options. The options value can be an object or a function that returns an object using the signature function(server) where server is the server the route is being added to and this is bound to the current realm's bind option. * rules - route custom rules object. The object is passed to each rules processor registered with server.rules(). Cannot be used if route.options.rules is defined. Return value: none. Note that the options object is deeply cloned (with the exception of bind which is shallowly copied) and cannot contain any values that are unsafe to perform deep copy on. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverrouteroute)

method rules

rules: (
    processor: (
        rules: object,
        info: { method: string; path: string; vhost?: string | undefined }
    ) => object,
    options?: { validate: object }
) => void;

• Defines a route rules processor for converting route rules object into route configuration where:

  Parameter processor

  a function using the signature function(rules, info) where: * rules - * info - an object with the following properties: * * method - the route method. * * path - the route path. * * vhost - the route virtual host (if any defined). * returns a route config object.

  Parameter options

  optional settings: * validate - rules object validation: * * schema - joi schema. * * options - optional joi validation options. Defaults to { allowUnknown: true }. Note that the root server and each plugin server instance can only register one rules processor. If a route is added after the rules are configured, it will not include the rules config. Routes added by plugins apply the rules to each of the parent realms' rules from the root to the route's realm. This means the processor defined by the plugin override the config generated by the root processor if they overlap. The route config overrides the rules config if the overlap. void [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverrulesprocessor-options)

method start

start: () => Promise<void>;

• Starts the server by listening for incoming requests on the configured port (unless the connection was configured with autoListen set to false). Return value: none. Note that if the method fails and throws an error, the server is considered to be in an undefined state and should be shut down. In most cases it would be impossible to fully recover as the various plugins, caches, and other event listeners will get confused by repeated attempts to start the server or make assumptions about the healthy state of the environment. It is recommended to abort the process when the server fails to start properly. If you must try to resume after an error, call server.stop() first to reset the server state. If a started server is started again, the second call to server.start() is ignored. No events will be emitted and no extension points invoked. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverstart)

method state

state: (name: string, options?: ServerStateCookieOptions) => void;

• HTTP state management uses client cookies to persist a state across multiple requests.

  Parameter name

  the cookie name string.

  Parameter options

  are the optional cookie settings Return value: none. State defaults can be modified via the server default state configuration option. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverstatename-options)

method stop

stop: (options?: { timeout: number }) => Promise<void>;

• Stops the server's listener by refusing to accept any new connections or requests (existing connections will continue until closed or timeout), where:

  Parameter options

  (optional) object with: * timeout - overrides the timeout in millisecond before forcefully terminating a connection. Defaults to 5000 (5 seconds). Return value: none. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverstopoptions)

method table

table: (host?: string) => RequestRoute[];

• Returns a copy of the routing table where:

  Parameter host

  (optional) host to filter routes matching a specific virtual host. Defaults to all virtual hosts. Return value: an array of routes where each route contains: * settings - the route config with defaults applied. * method - the HTTP method in lower case. * path - the route path. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servertablehost)

property data

readonly data?: AuthenticationData | undefined;

property error

readonly error?: Error | null | undefined;

property isAuth

readonly isAuth: true;

property app

app?: AppCredentials | undefined;

• If set, will only work with routes that set access.entity to app.

property scope

scope?: string[] | undefined;

• The application scopes to be granted. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-routeoptionsauthaccessscope)

property user

user?: UserCredentials | undefined;

• If set, will only work with routes that set access.entity to user.

property artifacts

artifacts?: object | undefined;

property credentials

credentials: AuthCredentials;

property defaults

defaults?: RouteOptions | ((method: any) => RouteOptions) | undefined;

call signature

(route: RouteOptions, options: any): Lifecycle.Method;

property channel

channel: 'internal' | 'app';

• set to 'internal' for internally generated events, otherwise 'app' for events generated by server.log()

property data

data: object;

• event-specific information. Available when event data was provided and is not an error. Errors are passed via error.

property error

error: object;

• the error object related to the event if applicable. Cannot appear together with data

property request

request: string;

• the request identifier.

property tags

tags: string[];

• an array of tags identifying the event (e.g. ['error', 'http'])

property timestamp

timestamp: string;

• the event timestamp.

property dependencies

dependencies?: Dependencies | undefined;

• (optional) a string or an array of strings indicating a plugin dependency. Same as setting dependencies via server.dependency().

property multiple

multiple?: boolean | undefined;

• (optional) if true, allows the plugin to be registered multiple times with the same server. Defaults to false.

property once

once?: boolean | undefined;

• once - (optional) if true, will only register the plugin once per server. If set, overrides the once option passed to server.register(). Defaults to no override.

property register

register: (server: Server, options: T) => void | Promise<void>;

• (required) the registration function with the signature async function(server, options) where: * server - the server object with a plugin-specific server.realm. * options - any options passed to the plugin during registration via server.register().

property requirements

requirements?:
    | {
          node?: string | undefined;
          hapi?: string | undefined;
      }
    | undefined;

• Allows defining semver requirements for node and hapi. Allows all.

property name

name: string;

• (required) the plugin name string. The name is used as a unique key. Published plugins (e.g. published in the npm registry) should use the same name as the name field in their 'package.json' file. Names must be unique within each application.

property version

version?: string | undefined;

• optional plugin version. The version is only used informatively to enable other plugins to find out the versions loaded. The version should be the same as the one specified in the plugin's 'package.json' file.

property pkg

pkg: any;

• Alternatively, the name and version can be included via the pkg property containing the 'package.json' file for the module which already has the name and version included

property name

name: string;

• the plugin name.

property options

options: object;

• options used to register the plugin.

property version

version: string;

• the plugin version.

method emit

emit: (criteria: K, listener: (value: T) => void) => void;

method hasListeners

hasListeners: (criteria: K) => this;

method on

on: (criteria: K, listener: (value: T) => void) => void;

method once

once: {
    (criteria: K, listener: (value: T) => void): void;
    (criteria: K): Promise<T>;
};

method removeAllListeners

removeAllListeners: (criteria: K) => this;

method removeListener

removeListener: (criteria: K, listener: Podium.Listener) => this;

property app

app: ApplicationState;

• Application-specific state. Provides a safe place to store application data without potential conflicts with the framework. Should not be used by plugins which should use plugins[name]. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestapp)

property auth

readonly auth: RequestAuth;

• Authentication information: * artifacts - an artifact object received from the authentication strategy and used in authentication-related actions. * credentials - the credential object received during the authentication process. The presence of an object does not mean successful authentication. * error - the authentication error is failed and mode set to 'try'. * isAuthenticated - true if the request has been successfully authenticated, otherwise false. * isAuthorized - true is the request has been successfully authorized against the route authentication access configuration. If the route has not access rules defined or if the request failed authorization, set to false. * mode - the route authentication mode. * strategy - the name of the strategy used. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestauth)

property events

events: RequestEvents;

• Access: read only and the public podium interface. The request.events supports the following events: * 'peek' - emitted for each chunk of payload data read from the client connection. The event method signature is function(chunk, encoding). * 'finish' - emitted when the request payload finished reading. The event method signature is function (). * 'disconnect' - emitted when a request errors or aborts unexpectedly. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestevents)

property headers

readonly headers: Util.Dictionary<string>;

• The raw request headers (references request.raw.req.headers). [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestheaders)

property info

readonly info: RequestInfo;

• Request information: * acceptEncoding - the request preferred encoding. * cors - if CORS is enabled for the route, contains the following: * isOriginMatch - true if the request 'Origin' header matches the configured CORS restrictions. Set to false if no 'Origin' header is found or if it does not match. Note that this is only available after the 'onRequest' extension point as CORS is configured per-route and no routing decisions are made at that point in the request lifecycle. * host - content of the HTTP 'Host' header (e.g. 'example.com:8080'). * hostname - the hostname part of the 'Host' header (e.g. 'example.com'). * id - a unique request identifier (using the format '{now}:{connection.info.id}:{5 digits counter}'). * received - request reception timestamp. * referrer - content of the HTTP 'Referrer' (or 'Referer') header. * remoteAddress - remote client IP address. * remotePort - remote client port. * responded - request response timestamp (0 is not responded yet). Note that the request.info object is not meant to be modified. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestinfo)

property logs

readonly logs: RequestLog[];

• An array containing the logged request events. Note that this array will be empty if route log.collect is set to false.

property method

readonly method: Util.HTTP_METHODS_PARTIAL_LOWERCASE;

• The request method in lower case (e.g. 'get', 'post').

property mime

readonly mime: string;

• The parsed content-type header. Only available when payload parsing enabled and no payload error occurred.

property orig

readonly orig: RequestOrig;

• An object containing the values of params, query, and payload before any validation modifications made. Only set when input validation is performed.

property params

readonly params: Util.Dictionary<string>;

• An object where each key is a path parameter name with matching value as described in [Path parameters](https://github.com/hapijs/hapi/blob/master/API.md#path-parameters).

property paramsArray

readonly paramsArray: string[];

• An array containing all the path params values in the order they appeared in the path.

property path

readonly path: string;

• The request URI's pathname component.

property payload

readonly payload: stream.Readable | Buffer | string | object;

• The request payload based on the route payload.output and payload.parse settings. TODO check this typing and add references / links.

property plugins

plugins: PluginsStates;

• Plugin-specific state. Provides a place to store and pass request-level plugin data. The plugins is an object where each key is a plugin name and the value is the state.

property pre

readonly pre: Util.Dictionary<any>;

• An object where each key is the name assigned by a route pre-handler methods function. The values are the raw values provided to the continuation function as argument. For the wrapped response object, use responses.

property preResponses

readonly preResponses: Util.Dictionary<any>;

• Same as pre but represented as the response object created by the pre method.

property query

readonly query: RequestQuery;

• By default the object outputted from node's URL parse() method.

property raw

readonly raw: {
    req: http.IncomingMessage;
    res: http.ServerResponse;
};

• An object containing the Node HTTP server objects. Direct interaction with these raw objects is not recommended. * req - the node request object. * res - the node response object.

property response

response: ResponseObject | Boom;

• Access: read / write (see limitations below). The response object when set. The object can be modified but must not be assigned another object. To replace the response with another from within an extension point, use reply(response) to override with a different response. In case of an aborted request the status code will be set to disconnectStatusCode.

property route

readonly route: RequestRoute;

• The request route information object and method [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestroute) [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestrouteauthaccessrequest)

property server

server: Server;

• Access: read only and the public server interface. The server object.

property state

readonly state: Util.Dictionary<any>;

• An object containing parsed HTTP state information (cookies) where each key is the cookie name and value is the matching cookie content after processing using any registered cookie definition.

property url

readonly url: url.URL;

• The parsed request URI.

method active

active: () => boolean;

• Returns true when the request is active and processing should continue and false when the request terminated early or completed its lifecycle. Useful when request processing is a resource-intensive operation and should be terminated early if the request is no longer active (e.g. client disconnected or aborted early).

method generateResponse

generateResponse: (
    source: string | object | null,
    options?: {
        variety?: string | undefined;
        prepare?: (response: ResponseObject) => Promise<ResponseObject>;
        marshal?: (response: ResponseObject) => Promise<ResponseValue>;
        close?: (response: ResponseObject) => void;
    }
) => ResponseObject;

• Returns a response which you can pass into the reply interface where:

  Parameter source

  the value to set as the source of the reply interface, optional.

  Parameter options

  options for the method, optional. ResponseObject [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestgenerateresponsesource-options)

method log

log: (
    tags: string | string[],
    data?: string | object | (() => string | object)
) => void;

• Logs request-specific events. When called, the server emits a 'request' event which can be used by other listeners or plugins. The arguments are:

  Parameter tags

  a string or an array of strings (e.g. ['error', 'database', 'read']) used to identify the event. Tags are used instead of log levels and provide a much more expressive mechanism for describing and filtering events.

  Parameter data

  (optional) an message string or object with the application data being logged. If data is a function, the function signature is function() and it called once to generate (return value) the actual data emitted to the listeners. Any logs generated by the server internally will be emitted only on the 'request-internal' channel and will include the event.internal flag set to true. void [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestlogtags-data)

method setMethod

setMethod: (method: Util.HTTP_METHODS_PARTIAL) => void;

• Changes the request method before the router begins processing the request where:

  Parameter method

  is the request HTTP method (e.g. 'GET'). void Can only be called from an 'onRequest' extension method. [See docs](https://hapijs.com/api/17.0.1#-requestsetmethodmethod)

method setUrl

setUrl: (url: string | url.URL, stripTrailingSlash?: boolean) => void;

• Changes the request URI before the router begins processing the request where: Can only be called from an 'onRequest' extension method.

  Parameter url

  the new request URI. If url is a string, it is parsed with node's URL parse() method with parseQueryString set to true. url can also be set to an object compatible with node's URL parse() method output.

  Parameter stripTrailingSlash

  if true, strip the trailing slash from the path. Defaults to false. void [See docs](https://hapijs.com/api/17.0.1#-requestseturlurl-striptrailingslash)

property artifacts

artifacts: object;

• an artifact object received from the authentication strategy and used in authentication-related actions.

property credentials

credentials: AuthCredentials;

• the credential object received during the authentication process. The presence of an object does not mean successful authentication.

property error

error: Error;

• the authentication error is failed and mode set to 'try'.

property isAuthenticated

isAuthenticated: boolean;

• true if the request has been successfully authenticated, otherwise false.

property isAuthorized

isAuthorized: boolean;

• true is the request has been successfully authorized against the route authentication access configuration. If the route has not access rules defined or if the request failed authorization, set to false.

property mode

mode: string;

• the route authentication mode.

property strategy

strategy: string;

• the name of the strategy used.

property channel

channel: 'internal' | 'app' | 'error';

• set to 'internal' for internally generated events, otherwise 'app' for events generated by server.log()

property data

data: object;

• event-specific information. Available when event data was provided and is not an error. Errors are passed via error.

property error

error: object;

• the error object related to the event if applicable. Cannot appear together with data

property tags

tags: string[];

• an array of tags identifying the event (e.g. ['error', 'http'])

property timestamp

timestamp: string;

• the event timestamp.

method on

on: {
    (criteria: 'peek', listener: PeekListener): void;
    (
        criteria: 'finish' | 'disconnect',
        listener: (data: undefined) => void
    ): void;
};

• Access: read only and the public podium interface. The request.events supports the following events: * 'peek' - emitted for each chunk of payload data read from the client connection. The event method signature is function(chunk, encoding). * 'finish' - emitted when the request payload finished reading. The event method signature is function (). * 'disconnect' - emitted when a request errors or aborts unexpectedly. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestevents)

method once

once: {
    (criteria: 'peek', listener: PeekListener): void;
    (
        criteria: 'finish' | 'disconnect',
        listener: (data: undefined) => void
    ): void;
};

• Access: read only and the public podium interface. The request.events supports the following events: * 'peek' - emitted for each chunk of payload data read from the client connection. The event method signature is function(chunk, encoding). * 'finish' - emitted when the request payload finished reading. The event method signature is function (). * 'disconnect' - emitted when a request errors or aborts unexpectedly. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-requestevents)

property acceptEncoding

acceptEncoding: string;

• the request preferred encoding.

property completed

completed: number;

• request processing completion timestamp (0 is still processing).

property cors

cors: {
    /**
     * true if the request 'Origin' header matches the configured CORS restrictions. Set to false if no 'Origin' header is found or if it does not match. Note that this is only available after
     * the 'onRequest' extension point as CORS is configured per-route and no routing decisions are made at that point in the request lifecycle.
     */
    isOriginMatch?: boolean | undefined;
};

• if CORS is enabled for the route, contains the following:

property host

host: string;

• content of the HTTP 'Host' header (e.g. 'example.com:8080').

property hostname

hostname: string;

• the hostname part of the 'Host' header (e.g. 'example.com').

property id

id: string;

• a unique request identifier (using the format '{now}:{connection.info.id}:{5 digits counter}')

property received

received: number;

• request reception timestamp.

property referrer

referrer: string;

• content of the HTTP 'Referrer' (or 'Referer') header.

property remoteAddress

remoteAddress: string;

• remote client IP address.

property remotePort

remotePort: string;

• remote client port.

property responded

responded: number;

• request response timestamp (0 is not responded yet).

property channel

channel: string;

property data

data: string | object;

property request

request: string;

property tags

tags: string[];

property timestamp

timestamp: number;

property params

params: object;

property payload

payload: object;

property query

query: object;

index signature

[key: string]: string | string[];

property auth

auth: {
    /**
     * Validates a request against the route's authentication access configuration, where:
     * @param request - the request object.
     * @return Return value: true if the request would have passed the route's access requirements.
     * Note that the route's authentication mode and strategies are ignored. The only match is made between the request.auth.credentials scope and entity information and the route access
     *     configuration. If the route uses dynamic scopes, the scopes are constructed against the request.query, request.params, request.payload, and request.auth.credentials which may or may
     *     not match between the route and the request's route. If this method is called using a request that has not been authenticated (yet or not at all), it will return false if the route
     *     requires any authentication.
     * [See docs](https://hapijs.com/api/17.0.1#-requestrouteauthaccessrequest)
     */
    access(request: Request): boolean;
};

property fingerprint

fingerprint: string;

• the route internal normalized string representing the normalized path.

property method

method: Util.HTTP_METHODS_PARTIAL;

• the route HTTP method.

property path

path: string;

• the route path.

property realm

realm: ServerRealm;

• the active realm associated with the route.

property settings

settings: RouteOptions;

• the route options object with all defaults applied.

property vhost

vhost?: string | string[] | undefined;

• the route vhost option if configured.

method on

on: {
    (criteria: 'peek', listener: PeekListener): void;
    (criteria: 'finish', listener: (data: undefined) => void): void;
};

• 'peek' - emitted for each chunk of data written back to the client connection. The event method signature is function(chunk, encoding). 'finish' - emitted when the response finished writing but before the client response connection is ended. The event method signature is function ().

method once

once: {
    (criteria: 'peek', listener: PeekListener): void;
    (criteria: 'finish', listener: (data: undefined) => void): void;
};

• 'peek' - emitted for each chunk of data written back to the client connection. The event method signature is function(chunk, encoding). 'finish' - emitted when the response finished writing but before the client response connection is ended. The event method signature is function ().

property app

app: ApplicationState;

• Default value: {}. Application-specific state. Provides a safe place to store application data without potential conflicts with the framework. Should not be used by plugins which should use plugins[name]. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responseapp)

property events

readonly events: ResponseEvents;

• Access: read only and the public podium interface. The response.events object supports the following events: * 'peek' - emitted for each chunk of data written back to the client connection. The event method signature is function(chunk, encoding). * 'finish' - emitted when the response finished writing but before the client response connection is ended. The event method signature is function (). [See docs](https://hapijs.com/api/17.0.1#-responseevents)

property headers

readonly headers: Util.Dictionary<string | string[]>;

• Default value: {}. An object containing the response headers where each key is a header field name and the value is the string header value or array of string. Note that this is an incomplete list of headers to be included with the response. Additional headers will be added once the response is prepared for transmission. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responseheaders)

property plugins

plugins: PluginsStates;

• Default value: {}. Plugin-specific state. Provides a place to store and pass request-level plugin data. plugins is an object where each key is a plugin name and the value is the state. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responseplugins)

property settings

readonly settings: ResponseSettings;

• Object containing the response handling flags. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsesettings)

property source

readonly source: Lifecycle.ReturnValue;

• The raw value returned by the lifecycle method. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsesource)

property statusCode

readonly statusCode: number;

• Default value: 200. The HTTP response status code. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsestatuscode)

property variety

readonly variety: 'plain' | 'buffer' | 'stream';

• A string indicating the type of source with available values: * 'plain' - a plain response such as string, number, null, or simple object. * 'buffer' - a Buffer. * 'stream' - a Stream. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsevariety)

method bytes

bytes: (length: number) => ResponseObject;

• Sets the HTTP 'Content-Length' header (to avoid chunked transfer encoding) where:

  Parameter length

  the header value. Must match the actual payload size. Return value: the current response object. [See docs](https://hapijs.com/api/17.0.1#-responsebyteslength)

method charset

charset: (charset: string) => ResponseObject;

• Sets the 'Content-Type' HTTP header 'charset' property where:

  Parameter charset

  the charset property value. Return value: the current response object. [See docs](https://hapijs.com/api/17.0.1#-responsecharsetcharset)

method code

code: (statusCode: number) => ResponseObject;

• Sets the HTTP status code where:

  Parameter statusCode

  the HTTP status code (e.g. 200). Return value: the current response object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsecodestatuscode)

method created

created: (uri: string) => ResponseObject;

• Sets the HTTP status code to Created (201) and the HTTP 'Location' header where:

  Parameter uri

  an absolute or relative URI used as the 'Location' header value. Return value: the current response object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responsecreateduri)

method encoding

encoding: (
    encoding:
        | 'ascii'
        | 'utf8'
        | 'utf16le'
        | 'ucs2'
        | 'base64'
        | 'latin1'
        | 'binary'
        | 'hex'
) => ResponseObject;

• Sets the string encoding scheme used to serial data into the HTTP payload where:

  Parameter encoding

  the encoding property value (see node Buffer encoding [See docs](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings)). * 'ascii' - for 7-bit ASCII data only. This encoding is fast and will strip the high bit if set. * 'utf8' - Multibyte encoded Unicode characters. Many web pages and other document formats use UTF-8. * 'utf16le' - 2 or 4 bytes, little-endian encoded Unicode characters. Surrogate pairs (U+10000 to U+10FFFF) are supported. * 'ucs2' - Alias of 'utf16le'. * 'base64' - Base64 encoding. When creating a Buffer from a string, this encoding will also correctly accept "URL and Filename Safe Alphabet" as specified in RFC4648, Section 5. * 'latin1' - A way of encoding the Buffer into a one-byte encoded string (as defined by the IANA in RFC1345, page 63, to be the Latin-1 supplement block and C0/C1 control codes). * 'binary' - Alias for 'latin1'. * 'hex' - Encode each byte as two hexadecimal characters. Return value: the current response object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responseencodingencoding)

method etag

etag: (
    tag: string,
    options?: { weak: boolean; vary: boolean }
) => ResponseObject;

• Sets the representation entity tag where:

  Parameter tag

  the entity tag string without the double-quote.

  Parameter options

  (optional) settings where: * weak - if true, the tag will be prefixed with the 'W/' weak signifier. Weak tags will fail to match identical tags for the purpose of determining 304 response status. Defaults to false. * vary - if true and content encoding is set or applied to the response (e.g 'gzip' or 'deflate'), the encoding name will be automatically added to the tag at transmission time (separated by a '-' character). Ignored when weak is true. Defaults to true. Return value: the current response object. [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-responseetagtag-options)