hapii-js 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,201 @@
+import { Server } from './server';
+import {
+    MergeType,
+    ReqRef,
+    ReqRefDefaults,
+    MergeRefs,
+    Request,
+    RequestAuth} from '../request';
+import { ResponseToolkit, AuthenticationData } from '../response';
+import { RouteOptionsAccess, InternalRouteOptionType, RouteOptionTypes} from '../route';
+import { Lifecycle } from '../utils';
+
+/**
+ * The scheme options argument passed to server.auth.strategy() when instantiation a strategy.
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthschemename-scheme)
+ */
+export type ServerAuthSchemeOptions = object;
+
+/**
+ * the method implementing the scheme with signature function(server, options) where:
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthschemename-scheme)
+ * @param server - a reference to the server object the scheme is added to.
+ * @param options - (optional) the scheme options argument passed to server.auth.strategy() when instantiation a strategy.
+ */
+export type ServerAuthScheme<
+    // tslint:disable-next-line no-unnecessary-generics
+    Options extends ServerAuthSchemeOptions = ServerAuthSchemeOptions,
+    // tslint:disable-next-line no-unnecessary-generics
+    Refs extends ReqRef = ReqRefDefaults
+> = (server: Server, options?: Options) => ServerAuthSchemeObject<Refs>;
+
+export interface ServerAuthSchemeObjectApi {}
+
+/**
+ * The scheme method must return an object with the following
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#authentication-scheme)
+ */
+
+export interface ServerAuthSchemeObject<Refs extends ReqRef = ReqRefDefaults> {
+    /**
+     * optional object which is exposed via the [server.auth.api](https://github.com/hapijs/hapi/blob/master/API.md#server.auth.api) object.
+     */
+    api?: MergeRefs<Refs>['AuthApi'] | undefined;
+
+    /**
+     * A lifecycle method function called for each incoming request configured with the authentication scheme. The
+     * method is provided with two special toolkit methods for returning an authenticated or an unauthenticated result:
+     * * h.authenticated() - indicate request authenticated successfully.
+     * * h.unauthenticated() - indicate request failed to authenticate.
+     * @param request the request object.
+     * @param h the ResponseToolkit
+     * @return the Lifecycle.ReturnValue
+     */
+    authenticate(request: Request<Refs>, h: ResponseToolkit<Refs>): Lifecycle.ReturnValue<Refs>;
+
+    /**
+     * A lifecycle method to authenticate the request payload.
+     * When the scheme payload() method returns an error with a message, it means payload validation failed due to bad
+     * payload. If the error has no message but includes a scheme name (e.g. Boom.unauthorized(null, 'Custom')),
+     * authentication may still be successful if the route auth.payload configuration is set to 'optional'.
+     * @param request the request object.
+     * @param h the ResponseToolkit
+     * @return the Lifecycle.ReturnValue
+     */
+    payload?(request: Request<Refs>, h: ResponseToolkit<Refs>): Lifecycle.ReturnValue<Refs>;
+
+    /**
+     * A lifecycle method to decorate the response with authentication headers before the response headers or payload is written.
+     * @param request the request object.
+     * @param h the ResponseToolkit
+     * @return the Lifecycle.ReturnValue
+     */
+    response?(request: Request<Refs>, h: ResponseToolkit<Refs>): Lifecycle.ReturnValue<Refs>;
+
+    /**
+     * a method used to verify the authentication credentials provided
+     * are still valid (e.g. not expired or revoked after the initial authentication).
+     * the method throws an `Error` when the credentials passed are no longer valid (e.g. expired or
+     * revoked). Note that the method does not have access to the original request, only to the
+     * credentials and artifacts produced by the `authenticate()` method.
+     */
+    verify?(
+        auth: RequestAuth<
+            MergeRefs<Refs>['AuthUser'],
+            MergeRefs<Refs>['AuthApp'],
+            MergeRefs<Refs>['AuthCredentialsExtra'],
+            MergeRefs<Refs>['AuthArtifactsExtra']
+        >
+    ): Promise<void>;
+
+    /**
+     * An object with the following keys:
+     * * payload
+     */
+    options?: {
+        /**
+         * if true, requires payload validation as part of the scheme and forbids routes from disabling payload auth validation. Defaults to false.
+         */
+        payload?: boolean | undefined;
+    } | undefined;
+}
+
+/**
+ * An authentication configuration object using the same format as the route auth handler options.
+ * For reference [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthdefaultoptions)
+ */
+
+export interface ServerAuthConfig extends RouteOptionsAccess {
+}
+
+export interface ServerAuth {
+    /**
+     * An object where each key is an authentication strategy name and the value is the exposed strategy API.
+     * Available only when the authentication scheme exposes an API by returning an api key in the object
+     * returned from its implementation function.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthapi)
+     */
+    api: Record<string, ServerAuthSchemeObjectApi>;
+
+    /**
+     * Contains the default authentication configuration is a default strategy was set via
+     * [server.auth.default()](https://github.com/hapijs/hapi/blob/master/API.md#server.auth.default()).
+     */
+    readonly settings: {
+        default: ServerAuthConfig;
+    };
+
+    /**
+     * Sets a default strategy which is applied to every route where:
+     * @param options - one of:
+     * * a string with the default strategy name
+     * * an authentication configuration object using the same format as the route auth handler options.
+     * @return void.
+     * The default does not apply when a route config specifies auth as false, or has an authentication strategy
+     * configured (contains the strategy or strategies authentication settings). Otherwise, the route authentication
+     * config is applied to the defaults.
+     * Note that if the route has authentication configured, the default only applies at the time of adding the route,
+     * not at runtime. This means that calling server.auth.default() after adding a route with some authentication
+     * config will have no impact on the routes added prior. However, the default will apply to routes added
+     * before server.auth.default() is called if those routes lack any authentication config.
+     * The default auth strategy configuration can be accessed via server.auth.settings.default. To obtain the active
+     * authentication configuration of a route, use server.auth.lookup(request.route).
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthdefaultoptions)
+     */
+    default(options: string | ServerAuthConfig): void;
+
+    /**
+     * Registers an authentication scheme where:
+     * @param name the scheme name.
+     * @param scheme - the method implementing the scheme with signature function(server, options) where:
+     * * server - a reference to the server object the scheme is added to.
+     * * options - (optional) the scheme options argument passed to server.auth.strategy() when instantiation a strategy.
+     * @return void.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthschemename-scheme)
+     */
+
+    scheme <
+        Refs extends ReqRef = ReqRefDefaults,
+        Options extends object = {}
+    // tslint:disable-next-line no-unnecessary-generics
+    >(name: string, scheme: ServerAuthScheme<Options, Refs>): void;
+
+    /**
+     * Registers an authentication strategy where:
+     * @param name - the strategy name.
+     * @param scheme - the scheme name (must be previously registered using server.auth.scheme()).
+     * @param options - scheme options based on the scheme requirements.
+     * @return Return value: none.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverauthstrategyname-scheme-options)
+     */
+    strategy(
+        name: MergeType<InternalRouteOptionType, RouteOptionTypes>['Strategy'],
+        scheme: string,
+        options?: object
+    ): void;
+
+    /**
+     * Tests a request against an authentication strategy where:
+     * @param strategy - the strategy name registered with server.auth.strategy().
+     * @param request - the request object.
+     * @return an object containing the authentication credentials and artifacts if authentication was successful, otherwise throws an error.
+     * Note that the test() method does not take into account the route authentication configuration. It also does not
+     * perform payload authentication. It is limited to the basic strategy authentication execution. It does not
+     * include verifying scope, entity, or other route properties.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-serverauthteststrategy-request)
+     */
+    test(strategy: string, request: Request): Promise<AuthenticationData>;
+
+    /**
+     * Verify a request's authentication credentials against an authentication strategy.
+     * Returns nothing if verification was successful, otherwise throws an error.
+     *
+     * Note that the `verify()` method does not take into account the route authentication configuration
+     * or any other information from the request other than the `request.auth` object. It also does not
+     * perform payload authentication. It is limited to verifying that the previously valid credentials
+     * are still valid (e.g. have not been revoked or expired). It does not include verifying scope,
+     * entity, or other route properties.
+     */
+    // tslint:disable-next-line no-unnecessary-generics
+    verify <Refs extends ReqRef = ReqRefDefaults>(request: Request<Refs>): Promise<void>;
+}

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

@@ -0,0 +1,85 @@
+import { PolicyOptionVariants, Policy, ClientApi, ClientOptions, EnginePrototype, PolicyOptions } from '@hapi/catbox';
+
+export type CachePolicyOptions<T> = PolicyOptionVariants<T> & {
+    /**
+     * @default '_default'
+     */
+    cache?: string | undefined;
+    segment?: string | undefined;
+};
+
+/**
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servercacheoptions)
+ */
+export interface ServerCache {
+    /**
+     * Provisions a cache segment within the server cache facility where:
+     * @param options - [catbox policy](https://github.com/hapijs/catbox#policy) configuration where:
+     * * expiresIn - relative expiration expressed in the number of milliseconds since the item was saved in the cache. Cannot be used together with expiresAt.
+     * * expiresAt - time of day expressed in 24h notation using the 'HH:MM' format, at which point all cache records expire. Uses local time. Cannot be used together with expiresIn.
+     * * generateFunc - a function used to generate a new cache item if one is not found in the cache when calling get(). The method's signature is async function(id, flags) where:
+     * - `id` - the `id` string or object provided to the `get()` method.
+     * - `flags` - an object used to pass back additional flags to the cache where:
+     * - `ttl` - the cache ttl value in milliseconds. Set to `0` to skip storing in the cache. Defaults to the cache global policy.
+     * * staleIn - number of milliseconds to mark an item stored in cache as stale and attempt to regenerate it when generateFunc is provided. Must be less than expiresIn.
+     * * staleTimeout - number of milliseconds to wait before checking if an item is stale.
+     * * generateTimeout - number of milliseconds to wait before returning a timeout error when the generateFunc function takes too long to return a value. When the value is eventually returned, it
+     *     is stored in the cache for future requests. Required if generateFunc is present. Set to false to disable timeouts which may cause all get() requests to get stuck forever.
+     * * generateOnReadError - if false, an upstream cache read error will stop the cache.get() method from calling the generate function and will instead pass back the cache error. Defaults to true.
+     * * generateIgnoreWriteError - if false, an upstream cache write error when calling cache.get() will be passed back with the generated value when calling. Defaults to true.
+     * * dropOnError - if true, an error or timeout in the generateFunc causes the stale value to be evicted from the cache. Defaults to true.
+     * * pendingGenerateTimeout - number of milliseconds while generateFunc call is in progress for a given id, before a subsequent generateFunc call is allowed. Defaults to 0 (no blocking of
+     *     concurrent generateFunc calls beyond staleTimeout).
+     * * cache - the cache name configured in server.cache. Defaults to the default cache.
+     * * segment - string segment name, used to isolate cached items within the cache partition. When called within a plugin, defaults to '!name' where 'name' is the plugin name. When called within a
+     *     server method, defaults to '#name' where 'name' is the server method name. Required when called outside of a plugin.
+     * * shared - if true, allows multiple cache provisions to share the same segment. Default to false.
+     * @return Catbox Policy.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servercacheoptions)
+     */
+    <T, O extends CachePolicyOptions<T> = CachePolicyOptions<T>>(options: O): Policy<T, O>;
+
+    /**
+     * Provisions a server cache as described in server.cache where:
+     * @param options - same as the server cache configuration options.
+     * @return Return value: none.
+     * Note that if the server has been initialized or started, the cache will be automatically started to match the state of any other provisioned server cache.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-servercacheprovisionoptions)
+     */
+    provision(options: ServerOptionsCache): Promise<void>;
+}
+
+export type CacheProvider<T extends ClientOptions = ClientOptions> = EnginePrototype<any> | {
+    constructor: EnginePrototype<any>;
+    options?: T | undefined;
+};
+
+/**
+ * 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.
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-cache)
+ */
+export interface ServerOptionsCache extends PolicyOptions<any> {
+    /** catbox engine object. */
+    engine?: ClientApi<any> | undefined;
+
+    /**
+     * a class or a prototype function
+     */
+    provider?: CacheProvider | undefined;
+
+    /**
+     * 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.
+     */
+    name?: string | undefined;
+
+    /** if true, allows multiple cache users to share the same segment (e.g. multiple methods using the same cache storage container). Default to false. */
+    shared?: boolean | undefined;
+
+    /** (optional) string used to isolate cached data. Defaults to 'hapi-cache'. */
+    partition?: string | undefined;
+
+    /** 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). */
+    [s: string]: any;
+}

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

@@ -0,0 +1,19 @@
+import { createDeflate, createGunzip, createGzip, createInflate } from 'zlib';
+
+/**
+ * Available [content encoders](https://github.com/hapijs/hapi/blob/master/API.md#-serverencoderencoding-encoder).
+ */
+export interface ContentEncoders {
+
+    deflate: typeof createDeflate;
+    gzip: typeof createGzip;
+}
+
+/**
+ * Available [content decoders](https://github.com/hapijs/hapi/blob/master/API.md#-serverdecoderencoding-decoder).
+ */
+export interface ContentDecoders {
+
+    deflate: typeof createInflate;
+    gzip: typeof createGunzip;
+}

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

@@ -0,0 +1,217 @@
+import { Podium } from '@hapi/podium';
+
+import { Request, RequestRoute } from '../request';
+
+/**
+ * an event name string.
+ * an event options object.
+ * a podium emitter object.
+ * For context [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servereventevents)
+ */
+export type ServerEventsApplication = string | ServerEventsApplicationObject | Podium;
+
+/**
+ * Object that it will be used in Event
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servereventevents)
+ */
+export interface ServerEventsApplicationObject {
+    /** the event name string (required). */
+    name: string;
+    /** a string or array of strings specifying the event channels available. Defaults to no channel restrictions (event updates can specify a channel or not). */
+    channels?: string | string[] | undefined;
+    /**
+     * 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).
+     */
+    clone?: boolean | undefined;
+    /**
+     * 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).
+     */
+    spread?: boolean | undefined;
+    /**
+     * 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.
+     */
+    tags?: boolean | undefined;
+    /**
+     * 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).
+     */
+    shared?: boolean | undefined;
+}
+
+/**
+ * A criteria object with the following optional keys (unless noted otherwise):
+ * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servereventsoncriteria-listener)
+ *
+ * The type parameter T is the type of the name of the event.
+ */
+export interface ServerEventCriteria<T> {
+    /** (required) the event name string. */
+    name: T;
+    /**
+     * a string or array of strings specifying the event channels to subscribe to. If the event registration specified a list of allowed channels, the channels array must match the allowed
+     * channels. If channels are specified, event updates without any channel designation will not be included in the subscription. Defaults to no channels filter.
+     */
+    channels?: string | string[] | undefined;
+    /** if true, the data object passed to server.event.emit() is cloned before it is passed to the listener method. Defaults to the event registration option (which defaults to false). */
+    clone?: boolean | undefined;
+    /**
+     * a positive integer indicating the number of times the listener can be called after which the subscription is automatically removed. A count of 1 is the same as calling server.events.once().
+     * Defaults to no limit.
+     */
+    count?: number | undefined;
+    /**
+     * filter - the event tags (if present) to subscribe to which can be one of:
+     * * a tag string.
+     * * an array of tag strings.
+     * * an object with the following:
+     * * * tags - a tag string or array of tag strings.
+     * * * all - if true, all tags must be present for the event update to match the subscription. Defaults to false (at least one matching tag).
+     */
+    filter?: string | string[] | { tags: string | string[] | undefined, all?: boolean | undefined } | undefined;
+    /**
+     * if true, and the data object passed to server.event.emit() is an array, the listener method is called with each array element passed as a separate argument. This should only be used
+     * when the emitted data structure is known and predictable. Defaults to the event registration option (which defaults to false).
+     */
+    spread?: boolean | undefined;
+    /**
+     * 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. Defaults to the event registration option (which defaults to false).
+     */
+    tags?: boolean | undefined;
+}
+
+export interface LogEvent<T = object | string> {
+    /** the event timestamp. */
+    timestamp: string;
+    /** an array of tags identifying the event (e.g. ['error', 'http']) */
+    tags: string[];
+    /** set to 'internal' for internally generated events, otherwise 'app' for events generated by server.log() */
+    channel: 'internal' | 'app';
+    /** the request identifier. */
+    request: string;
+    /** event-specific information. Available when event data was provided and is not an error. Errors are passed via error. */
+    data: T;
+    /** the error object related to the event if applicable. Cannot appear together with data */
+    error: object;
+}
+
+export interface RequestEvent {
+    /** the event timestamp. */
+    timestamp: string;
+    /** an array of tags identifying the event (e.g. ['error', 'http']) */
+    tags: string[];
+    /** set to 'internal' for internally generated events, otherwise 'app' for events generated by server.log() */
+    channel: 'internal' | 'app' | 'error';
+    /** event-specific information. Available when event data was provided and is not an error. Errors are passed via error. */
+    data: object | string;
+    /** the error object related to the event if applicable. Cannot appear together with data */
+    error: object;
+}
+
+export type LogEventHandler = (event: LogEvent, tags: { [key: string]: true }) => void;
+export type RequestEventHandler = (request: Request, event: RequestEvent, tags: { [key: string]: true }) => void;
+export type ResponseEventHandler = (request: Request) => void;
+export type RouteEventHandler = (route: RequestRoute) => void;
+export type StartEventHandler = () => void;
+export type StopEventHandler = () => void;
+
+export interface PodiumEvent<K extends string, T> {
+    emit(criteria: K, listener: (value: T) => void): void;
+
+    on(criteria: K, listener: (value: T) => void): void;
+
+    once(criteria: K, listener: (value: T) => void): void;
+
+    once(criteria: K): Promise<T>;
+
+    removeListener(criteria: K, listener: Podium.Listener): this;
+
+    removeAllListeners(criteria: K): this;
+
+    hasListeners(criteria: K): this;
+}
+
+/**
+ * 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.event(events)](https://github.com/hapijs/hapi/blob/master/API.md#server.event()) - register application 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)
+ */
+export interface ServerEvents extends Podium {
+    /**
+     * Subscribe to an event where:
+     * @param criteria - the subscription criteria which must be one of:
+     * * event name string which can be any of the built-in server events
+     * * a custom application event registered with server.event().
+     * * a criteria object
+     * @param listener - the handler method set to receive event updates. The function signature depends on the event argument, and the spread and tags options.
+     * @return Return value: none.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servereventsoncriteria-listener)
+     * See ['log' event](https://github.com/hapijs/hapi/blob/master/API.md#-log-event)
+     * See ['request' event](https://github.com/hapijs/hapi/blob/master/API.md#-request-event)
+     * See ['response' event](https://github.com/hapijs/hapi/blob/master/API.md#-response-event)
+     * See ['route' event](https://github.com/hapijs/hapi/blob/master/API.md#-route-event)
+     * See ['start' event](https://github.com/hapijs/hapi/blob/master/API.md#-start-event)
+     * See ['stop' event](https://github.com/hapijs/hapi/blob/master/API.md#-stop-event)
+     */
+    on(criteria: 'log' | ServerEventCriteria<'log'>, listener: LogEventHandler): this;
+    on(criteria: 'request' | ServerEventCriteria<'request'>, listener: RequestEventHandler): this;
+    on(criteria: 'response' | ServerEventCriteria<'response'>, listener: ResponseEventHandler): this;
+    on(criteria: 'route' | ServerEventCriteria<'route'>, listener: RouteEventHandler): this;
+    on(criteria: 'start' | ServerEventCriteria<'start'>, listener: StartEventHandler): this;
+    on(criteria: 'stop' | ServerEventCriteria<'stop'>, listener: StopEventHandler): this;
+    on(criteria: string | ServerEventCriteria<string>, listener: (value: any) => void): this;
+
+    /**
+     * Same as calling [server.events.on()](https://github.com/hapijs/hapi/blob/master/API.md#server.events.on()) with the count option set to 1.
+     * @param criteria - the subscription criteria which must be one of:
+     * * event name string which can be any of the built-in server events
+     * * a custom application event registered with server.event().
+     * * a criteria object
+     * @param listener - the handler method set to receive event updates. The function signature depends on the event argument, and the spread and tags options.
+     * @return Return value: none.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-servereventsoncecriteria-listener)
+     */
+    once(criteria: 'log' | ServerEventCriteria<'log'>, listener: LogEventHandler): this;
+    once(criteria: 'request' | ServerEventCriteria<'request'>, listener: RequestEventHandler): this;
+    once(criteria: 'response' | ServerEventCriteria<'response'>, listener: ResponseEventHandler): this;
+    once(criteria: 'route' | ServerEventCriteria<'route'>, listener: RouteEventHandler): this;
+    once(criteria: 'start' | ServerEventCriteria<'start'>, listener: StartEventHandler): this;
+    once(criteria: 'stop' | ServerEventCriteria<'stop'>, listener: StopEventHandler): this;
+
+    /**
+     * Same as calling server.events.on() with the count option set to 1.
+     * @param criteria - the subscription criteria which must be one of:
+     * * event name string which can be any of the built-in server events
+     * * a custom application event registered with server.event().
+     * * a criteria object
+     * @return Return value: a promise that resolves when the event is emitted.
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-await-servereventsoncecriteria)
+     */
+    once(criteria: string | ServerEventCriteria<string>): Promise<any>;
+
+    /**
+     * The follow method is only mentioned in Hapi API. The doc about that method can be found [here](https://github.com/hapijs/podium/blob/master/API.md#podiumremovelistenername-listener)
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverevents)
+     */
+    removeListener(name: string, listener: Podium.Listener): this;
+
+    /**
+     * The follow method is only mentioned in Hapi API. The doc about that method can be found [here](https://github.com/hapijs/podium/blob/master/API.md#podiumremovealllistenersname)
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverevents)
+     */
+    removeAllListeners(name: string): this;
+
+    /**
+     * The follow method is only mentioned in Hapi API. The doc about that method can be found [here](https://github.com/hapijs/podium/blob/master/API.md#podiumhaslistenersname)
+     * [See docs](https://github.com/hapijs/hapi/blob/master/API.md#-serverevents)
+     */
+    hasListeners(name: string): boolean;
+}