jimpex 7.0.1 → 8.0.0

package/types/controllers/utils/gateway.d.ts

@@ -1,947 +0,0 @@
-export type ExpressRouter = import('../../types').ExpressRouter;
-export type Jimpex = import('../../app').Jimpex;
-export type ExpressRequest = import('../../types').ExpressRequest;
-export type ExpressResponse = import('../../types').ExpressResponse;
-export type ExpressNext = import('../../types').ExpressNext;
-export type ExpressMiddleware = import('../../types').ExpressMiddleware;
-export type MiddlewareLike = import('../../types').MiddlewareLike;
-export type HTTP = import('../../services/http/http').HTTP;
-export type HTTPFetchOptions = import('../../services/http/http').HTTPFetchOptions;
-export type Response = import('../../services/http/http').Response;
-export type APIClientConfiguration = import('../../services/http/apiClient').APIClientConfiguration;
-/**
- * <O>
- */
-export type ProviderCreator<O> = import('../../types').ProviderCreator<O>;
-/**
- * This object represets an HTTP method for a route the controller will mount.
- */
-export type GatewayControllerRouteMethod = {
-    /**
-     * The name of the HTTP method.
-     */
-    method: string;
-    /**
-     * The information for the endpoint responsible from creating the route.
-     */
-    endpoint: GatewayControllerEndpointInformation;
-};
-/**
- * This object contains the information for an specific route the controller will mount.
- */
-export type GatewayControllerRoute = {
-    /**
-     * The path to the endpoint relative
-     * to the entry point.
-     */
-    path: string;
-    /**
-     * The path the route will have. This
-     * is different from `path` as it's
-     * possible for the gateway to be
-     * implemented using the `root`
-     * option.
-     */
-    route: string;
-    /**
-     * A list with all the methods the
-     * controller will use to mount the
-     * route.
-     */
-    methods: GatewayControllerRouteMethod[];
-};
-/**
- * Normally, you would define an endpoint with just a string path, but you can use this
- * type of object to add extra settings.
- */
-export type GatewayConfigurationEndpoint = {
-    /**
-     * The path to the endpoint relative to the entry point. It can
-     * include placeholders for parameters like `/:parameter/`.
-     */
-    path: string;
-    /**
-     * The HTTP method for the endpoint. This will tell the gateway
-     * the type of route it should mount. If is not specified, it
-     * will use `all`.
-     */
-    method: string;
-};
-/**
- * A dictionary of endpoints or sub endpoints the gateway will use in order to mount
- * routes.
- */
-export type GatewayConfigurationEndpoints = {
-    /**
-     * It can be the path to an actual endpoint, a dictionary of sub endpoints, or a
-     * definition of an endpoint with settings ({@link GatewayConfigurationEndpoint }).
-     */
-    endpointName?: string | GatewayConfigurationEndpoints | GatewayConfigurationEndpoint;
-};
-/**
- * This is a configuration object very similar to the one {@link APIClient } uses in order
- * to configure the endpoints; the controller uses it to create the routes and to validate
- * the HTTP methods.
- */
-export type GatewayConfiguration = {
-    /**
-     * The entry point to the API the
-     * controller will make the requests
-     * to.
-     */
-    url: string;
-    /**
-     * A dictionary with the endpoints the
-     * gateway will make available.
-     */
-    gateway: GatewayConfigurationEndpoints;
-};
-/**
- * The options for how the gateway will handle the headers from the requests and the
- * responses.
- */
-export type GatewayControllerHeadersOptions = {
-    /**
-     * Whether or not to include the header with the
-     * request's IP address. Default `true`.
-     */
-    useXForwardedFor: boolean;
-    /**
-     * Whether or not to copy all custom headers from
-     * the request. By custom header, it means all the
-     * headers which names start with `x-`. Default
-     * `true`.
-     */
-    copyCustomHeaders: boolean;
-    /**
-     * A list of "known" headers the gateway will try
-     * to copy from the incoming request. Default:
-     * `['authorization','content-type', 'referer',
-     * 'user-agent']`.
-     */
-    copy: string[];
-    /**
-     * A list of "known" headers the gateway will try
-     * to remove the response. Default:
-     * `['server', 'x-powered-by']`.
-     */
-    remove: string[];
-};
-/**
- * The options to configure how the gateway will manage the requests and the responses.
- */
-export type GatewayControllerOptions = {
-    /**
-     * This is really a helper for when the gateway is used with an API client. The idea is
-     * that,
-     * by default, the routes are mounted on the controller route, but with this option, you
-     * can specify another sub path. For example: The controller is mounted on `/routes`, if
-     * you set `root` to `gateway`, all the routes will be on `/routes/gateway`.
-     * This become important (and useful) when you get the API client configuration (with
-     * `endpointsForAPIClient`): The `url` will be the controller route, but all the endpoints
-     * will be modified and prefixed with the `root`. Default `''`.
-     */
-    root: string;
-    /**
-     * This is another option for when the gateway is used with an API client. When calling
-     * `endpointsForAPIClient`, all the endpoints will be wrapped inside an object named after
-     * this option. For example: `{ url: '...', endpoints: { api: { ... } } }`. Default `api`.
-     */
-    configurationSetting: string;
-    /**
-     * The options for how the gateway will handle the headers from the requests and the
-     * responses.
-     */
-    headers: GatewayControllerHeadersOptions;
-};
-/**
- * This are the options sent to the controller creator that instantiates
- * {@link GatewayController }.
- * They're basically the same as {@link GatewayControllerOptions } but with a couple of
- * extra ones.
- */
-export type GatewayControllerCreatorOptions = {
-    /**
-     * The name of the creator will use to register the controller in the container. No, this
-     * is not a typo. The creator will register the controller so other services can access
-     * the `endpointsForAPIClient` getter. The service will be available after the app routes
-     * are mounted.
-     * If this is overwritten, the creator will ensure that the name ends with `Gateway`; and
-     * if overwritten, but it doesn't include `Gateway` at the end, and no
-     * `configurationSetting` was defined, the creator will use the custom name (without
-     * `Gatway`) for `configurationSetting`.
-     * Default `'apiGeteway'`.
-     */
-    serviceName: string;
-    /**
-     * The name of the helper service the creator will try to obtain from the container. If
-     * `serviceName` is overwritten, the default for this will be `${serviceName}Helper`.
-     * Default:
-     * `'apiGatewayHelper'`.
-     */
-    helperServiceName: string;
-    /**
-     * The name of the configuration setting where the gateway configuration is stored. If not
-     * overwritten, check the description of `serviceName` to understand which will be its
-     * default value. Default `'api'`.
-     */
-    configurationSetting: string;
-    /**
-     * The class the creator will instantiate. Similar to {@link APIClient }, this allows for
-     * extra customization in cases you may need multiple gateways. Default
-     * {@link GatewayController }.
-     */
-    gatewayClass: typeof GatewayController;
-    /**
-     * This function can be used to add custom middlewares on the gateway routes. If
-     * implemented, it must return a list of middlewares when executed. Default `null`.
-     */
-    middlewares: GatewayControllerMiddlewaresFn | null;
-};
-/**
- * This is the information for a request the controller will make.
- */
-export type GatewayControllerRequest = {
-    /**
-     * The URL for the request.
-     */
-    url: string;
-    /**
-     * The request options.
-     */
-    options: HTTPFetchOptions;
-};
-/**
- * This is the information for an specific endpoint that the gateway may use to send to a
- * helper method in order to give it context.
- */
-export type GatewayControllerEndpointInformation = {
-    /**
-     * The name of the endpoint, which is actually the path inside the gateway configuration's
-     * `gateway` property.
-     */
-    name: string;
-    /**
-     * The path for the endpoint, or the dictionary of settings.
-     */
-    settings: string | GatewayConfigurationEndpoint;
-};
-/**
- * This is called in order to allow the helper to modify the information of a request that
- * is about the fired.
- */
-export type GatewayHelperServiceRequestReducer = (request: GatewayControllerRequest, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => GatewayControllerRequest;
-/**
- * This is called in order to allow the helper to modify the information of a response the
- * gateway made.
- */
-export type GatewayHelperServiceResponseReducer = (response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => any;
-/**
- * This is called in order to allow the helper to decide whether a fetch request response
- * should be added to the server's response stream. This will only be called if the helper
- * also implements `handleEndpointResponse`.
- */
-export type GatewayHelperServiceStreamVerification = (response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => boolean;
-/**
- * This is called in order for the helper to handle a response. This is only called if
- * `shouldStreamEndpointResponse` returned `false`.
- */
-export type GatewayHelperServiceResponseHandler = (response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => any;
-/**
- * This is called in order for the helper to handle a fetch request error.
- */
-export type GatewayHelperServiceErrorHandler = (error: Error, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => any;
-/**
- * A service that can have specific methods the gateway will call in order to modify
- * requests,
- * responses, handle errors, etc.
- */
-export type GatewayHelperService = {
-    /**
-     * This is called in order to allow the helper to modify the information of a request that
-     * is about the fired.
-     */
-    reduceEndpointRequest: GatewayHelperServiceRequestReducer | null;
-    /**
-     * This is called in order to allow the helper to modify the information of a response the
-     * gateway made.
-     */
-    reduceEndpointResponse: GatewayHelperServiceResponseReducer | null;
-    /**
-     * This is called in order to allow the helper to decide whether a fetch request response
-     * should be added to the server's response stream. This will only be called if the helper
-     * also implements `handleEndpointResponse`.
-     */
-    shouldStreamEndpointResponse: GatewayHelperServiceStreamVerification | null;
-    /**
-     * This is called in order for the helper to handle a response. This is only called if
-     * `shouldStreamEndpointResponse` returned `false`.
-     */
-    handleEndpointResponse: GatewayHelperServiceResponseHandler | null;
-    /**
-     * This is called in order for the helper to handle a fetch request error.
-     */
-    handleEndpointError: GatewayHelperServiceErrorHandler | null;
-};
-export type GatewayControllerMiddlewaresFn = (app: Jimpex) => MiddlewareLike[];
-/**
- * @typedef {import('../../types').ExpressRouter} ExpressRouter
- * @typedef {import('../../app').Jimpex} Jimpex
- * @typedef {import('../../types').ExpressRequest} ExpressRequest
- * @typedef {import('../../types').ExpressResponse} ExpressResponse
- * @typedef {import('../../types').ExpressNext} ExpressNext
- * @typedef {import('../../types').ExpressMiddleware} ExpressMiddleware
- * @typedef {import('../../types').MiddlewareLike} MiddlewareLike
- * @typedef {import('../../services/http/http').HTTP} HTTP
- * @typedef {import('../../services/http/http').HTTPFetchOptions} HTTPFetchOptions
- * @typedef {import('../../services/http/http').Response} Response
- * @typedef {import('../../services/http/apiClient').APIClientConfiguration} APIClientConfiguration
- * @prettierignore
- */
-/**
- * @typedef {import('../../types').ProviderCreator<O>} ProviderCreator<O>
- * @template O
- */
-/**
- * This object represets an HTTP method for a route the controller will mount.
- *
- * @typedef {Object} GatewayControllerRouteMethod
- * @property {string} method
- * The name of the HTTP method.
- * @property {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible from creating the route.
- * @parent module:controllers
- * @ignore
- */
-/**
- * This object contains the information for an specific route the controller will mount.
- *
- * @typedef {Object} GatewayControllerRoute
- * @property {string}                         path     The path to the endpoint relative
- *                                                     to the entry point.
- * @property {string}                         route    The path the route will have. This
- *                                                     is different from `path` as it's
- *                                                     possible for the gateway to be
- *                                                     implemented using the `root`
- *                                                     option.
- * @property {GatewayControllerRouteMethod[]} methods  A list with all the methods the
- *                                                     controller will use to mount the
- *                                                     route.
- * @parent module:controllers
- * @ignore
- */
-/**
- * Normally, you would define an endpoint with just a string path, but you can use this
- * type of object to add extra settings.
- *
- * @typedef {Object} GatewayConfigurationEndpoint
- * @property {string} path    The path to the endpoint relative to the entry point. It can
- *                            include placeholders for parameters like `/:parameter/`.
- * @property {string} method  The HTTP method for the endpoint. This will tell the gateway
- *                            the type of route it should mount. If is not specified, it
- *                            will use `all`.
- * @parent module:controllers
- */
-/**
- * A dictionary of endpoints or sub endpoints the gateway will use in order to mount
- * routes.
- *
- * @typedef {Object} GatewayConfigurationEndpoints
- * @property {string | GatewayConfigurationEndpoints | GatewayConfigurationEndpoint} [endpointName]
- * It can be the path to an actual endpoint, a dictionary of sub endpoints, or a
- * definition of an endpoint with settings ({@link GatewayConfigurationEndpoint}).
- * @parent module:controllers
- * @prettierignore
- */
-/**
- * This is a configuration object very similar to the one {@link APIClient} uses in order
- * to configure the endpoints; the controller uses it to create the routes and to validate
- * the HTTP methods.
- *
- * @typedef {Object} GatewayConfiguration
- * @property {string}                        url      The entry point to the API the
- *                                                    controller will make the requests
- *                                                    to.
- * @property {GatewayConfigurationEndpoints} gateway  A dictionary with the endpoints the
- *                                                    gateway will make available.
- * @parent module:controllers
- */
-/**
- * The options for how the gateway will handle the headers from the requests and the
- * responses.
- *
- * @typedef {Object} GatewayControllerHeadersOptions
- * @property {boolean}  useXForwardedFor   Whether or not to include the header with the
- *                                         request's IP address. Default `true`.
- * @property {boolean}  copyCustomHeaders  Whether or not to copy all custom headers from
- *                                         the request. By custom header, it means all the
- *                                         headers which names start with `x-`. Default
- *                                         `true`.
- * @property {string[]} copy               A list of "known" headers the gateway will try
- *                                         to copy from the incoming request. Default:
- *                                         `['authorization','content-type', 'referer',
- *                                         'user-agent']`.
- * @property {string[]} remove             A list of "known" headers the gateway will try
- *                                         to remove the response. Default:
- *                                         `['server', 'x-powered-by']`.
- * @parent module:controllers
- */
-/**
- * The options to configure how the gateway will manage the requests and the responses.
- *
- * @typedef {Object} GatewayControllerOptions
- * @property {string} root
- * This is really a helper for when the gateway is used with an API client. The idea is
- * that,
- * by default, the routes are mounted on the controller route, but with this option, you
- * can specify another sub path. For example: The controller is mounted on `/routes`, if
- * you set `root` to `gateway`, all the routes will be on `/routes/gateway`.
- * This become important (and useful) when you get the API client configuration (with
- * `endpointsForAPIClient`): The `url` will be the controller route, but all the endpoints
- * will be modified and prefixed with the `root`. Default `''`.
- * @property {string} configurationSetting
- * This is another option for when the gateway is used with an API client. When calling
- * `endpointsForAPIClient`, all the endpoints will be wrapped inside an object named after
- * this option. For example: `{ url: '...', endpoints: { api: { ... } } }`. Default `api`.
- * @property {GatewayControllerHeadersOptions} headers
- * The options for how the gateway will handle the headers from the requests and the
- * responses.
- * @parent module:controllers
- */
-/**
- * This are the options sent to the controller creator that instantiates
- * {@link GatewayController}.
- * They're basically the same as {@link GatewayControllerOptions} but with a couple of
- * extra ones.
- *
- * @typedef {Object} GatewayControllerCreatorOptions
- * @property {string} serviceName
- * The name of the creator will use to register the controller in the container. No, this
- * is not a typo. The creator will register the controller so other services can access
- * the `endpointsForAPIClient` getter. The service will be available after the app routes
- * are mounted.
- * If this is overwritten, the creator will ensure that the name ends with `Gateway`; and
- * if overwritten, but it doesn't include `Gateway` at the end, and no
- * `configurationSetting` was defined, the creator will use the custom name (without
- * `Gatway`) for `configurationSetting`.
- * Default `'apiGeteway'`.
- * @property {string} helperServiceName
- * The name of the helper service the creator will try to obtain from the container. If
- * `serviceName` is overwritten, the default for this will be `${serviceName}Helper`.
- * Default:
- * `'apiGatewayHelper'`.
- * @property {string} configurationSetting
- * The name of the configuration setting where the gateway configuration is stored. If not
- * overwritten, check the description of `serviceName` to understand which will be its
- * default value. Default `'api'`.
- * @property {typeof GatewayController} gatewayClass
- * The class the creator will instantiate. Similar to {@link APIClient}, this allows for
- * extra customization in cases you may need multiple gateways. Default
- * {@link GatewayController}.
- * @property {?GatewayControllerMiddlewaresFn} middlewares
- * This function can be used to add custom middlewares on the gateway routes. If
- * implemented, it must return a list of middlewares when executed. Default `null`.
- * @parent module:controllers
- */
-/**
- * This is the information for a request the controller will make.
- *
- * @typedef {Object} GatewayControllerRequest
- * @property {string}           url      The URL for the request.
- * @property {HTTPFetchOptions} options  The request options.
- * @parent module:controllers
- */
-/**
- * This is the information for an specific endpoint that the gateway may use to send to a
- * helper method in order to give it context.
- *
- * @typedef {Object} GatewayControllerEndpointInformation
- * @property {string} name
- * The name of the endpoint, which is actually the path inside the gateway configuration's
- * `gateway` property.
- * @property {string | GatewayConfigurationEndpoint} settings
- * The path for the endpoint, or the dictionary of settings.
- * @parent module:controllers
- */
-/**
- * This is called in order to allow the helper to modify the information of a request that
- * is about the fired.
- *
- * @callback GatewayHelperServiceRequestReducer
- * @param {GatewayControllerRequest} request
- * The information for a request the controller will make.
- * @param {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible of creating the route.
- * @param {ExpressRequest} req
- * The server's incoming request information.
- * @param {ExpressResponse} res
- * The server's response information.
- * @param {ExpressNext} next
- * The function to call the next middleware.
- * @returns {GatewayControllerRequest}
- * @parent module:controllers
- */
-/**
- * This is called in order to allow the helper to modify the information of a response the
- * gateway made.
- *
- * @callback GatewayHelperServiceResponseReducer
- * @param {Response} response
- * The response generated by the fetch request.
- * @param {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible of creating the route.
- * @param {ExpressRequest} req
- * The server's incoming request information.
- * @param {ExpressResponse} res
- * The server's response information.
- * @param {ExpressNext} next
- * The function to call the next middleware.
- * @returns {Response}
- * @parent module:controllers
- */
-/**
- * This is called in order to allow the helper to decide whether a fetch request response
- * should be added to the server's response stream. This will only be called if the helper
- * also implements `handleEndpointResponse`.
- *
- * @callback GatewayHelperServiceStreamVerification
- * @param {Response} response
- * The response generated by the fetch request.
- * @param {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible of creating the route.
- * @param {ExpressRequest} req
- * The server's incoming request information.
- * @param {ExpressResponse} res
- * The server's response information.
- * @param {ExpressNext} next
- * The function to call the next middleware.
- * @returns {boolean}
- * @parent module:controllers
- */
-/**
- * This is called in order for the helper to handle a response. This is only called if
- * `shouldStreamEndpointResponse` returned `false`.
- *
- * @callback GatewayHelperServiceResponseHandler
- * @param {Response} response
- * The response generated by the fetch request.
- * @param {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible of creating the route.
- * @param {ExpressRequest} req
- * The server's incoming request information.
- * @param {ExpressResponse} res
- * The server's response information.
- * @param {ExpressNext} next
- * The function to call the next middleware.
- * @parent module:controllers
- */
-/**
- * This is called in order for the helper to handle a fetch request error.
- *
- * @callback GatewayHelperServiceErrorHandler
- * @param {Error} error
- * The fetch request error.
- * @param {GatewayControllerEndpointInformation} endpoint
- * The information for the endpoint responsible of creating the route.
- * @param {ExpressRequest} req
- * The server's incoming request information.
- * @param {ExpressResponse} res
- * The server's response information.
- * @param {ExpressNext} next
- * The function to call the next middleware.
- * @parent module:controllers
- */
-/**
- * A service that can have specific methods the gateway will call in order to modify
- * requests,
- * responses, handle errors, etc.
- *
- * @typedef {Object} GatewayHelperService
- * @property {?GatewayHelperServiceRequestReducer} reduceEndpointRequest
- * This is called in order to allow the helper to modify the information of a request that
- * is about the fired.
- * @property {?GatewayHelperServiceResponseReducer} reduceEndpointResponse
- * This is called in order to allow the helper to modify the information of a response the
- * gateway made.
- * @property {?GatewayHelperServiceStreamVerification} shouldStreamEndpointResponse
- * This is called in order to allow the helper to decide whether a fetch request response
- * should be added to the server's response stream. This will only be called if the helper
- * also implements `handleEndpointResponse`.
- * @property {?GatewayHelperServiceResponseHandler} handleEndpointResponse
- * This is called in order for the helper to handle a response. This is only called if
- * `shouldStreamEndpointResponse` returned `false`.
- * @property {?GatewayHelperServiceErrorHandler} handleEndpointError
- * This is called in order for the helper to handle a fetch request error.
- * @parent module:controllers
- */
-/**
- * @callback GatewayControllerMiddlewaresFn
- * @param {Jimpex} app  A reference for the container.
- * @returns {MiddlewareLike[]}
- * @parent module:controllers
- */
-/**
- * Geneters routes that will act as a gateway to an specific set of endpoints.
- *
- * @parent module:controllers
- */
-export class GatewayController {
-    /**
-     * @param {GatewayConfiguration} gatewayConfig
-     * This is a configuration object very similar to the one {@link APIClient} uses in
-     * order to configure the endpoints; the controller uses it to create the routes and to
-     * validate the HTTP methods.
-     * @param {string} route
-     * The route where the controller will be mounted.
-     * @param {HTTP} http
-     * To make the fetch requests on the routes.
-     * @param {GatewayControllerOptions} [options={}]
-     * The options to configure how the gateway will manage the requests and the responses.
-     * @param {?GatewayHelperService} [helperService=null]
-     * A service that can have specific methods the gateway will call in order to modify
-     * requests,
-     * responses, handle errors, etc.
-     */
-    constructor(gatewayConfig: GatewayConfiguration, route: string, http: HTTP, options?: GatewayControllerOptions, helperService?: GatewayHelperService | null);
-    /**
-     * The options to configure how the gateway will manage the requests and the
-     * responses.
-     *
-     * @type {GatewayControllerOptions}
-     * @access protected
-     * @ignore
-     * @todo Use deepAssign for this merge.
-     */
-    _options: GatewayControllerOptions;
-    /**
-     * The configuration for the API the controller will make requests to.
-     *
-     * @type {GatewayConfiguration}
-     * @access protected
-     * @ignore
-     */
-    _gatewayConfig: GatewayConfiguration;
-    /**
-     * A local reference for the `http` service.
-     *
-     * @type {HTTP}
-     * @access protected
-     * @ignore
-     */
-    _http: HTTP;
-    /**
-     * A list of the allowed HTTP methods an endpoint can have.
-     *
-     * @type {string[]}
-     * @access protected
-     * @ignore
-     */
-    _allowedHTTPMethods: string[];
-    /**
-     * A flat dictionary of the gateway endpoints. The key is the path on the original
-     * dictionary (`this._gatewayConfig.gateway`) and the value is either the path
-     * (`string`)
-     * or the endpoint settings ({@link GatewayConfigurationEndpoint}).
-     *
-     * @type {Object.<string, string | GatewayConfigurationEndpoint>}
-     * @access protected
-     * @ignore
-     */
-    _endpoints: {
-        [x: string]: string | GatewayConfigurationEndpoint;
-    };
-    /**
-     * The route where the controller is mounted.
-     *
-     * @type {string}
-     * @access protected
-     * @ignore
-     */
-    _route: string;
-    /**
-     * A regular expression that will be used to remove the controller route from a
-     * request path. This will allow the main middleware to extract the path to where the
-     * request should be made.
-     *
-     * @type {RegExp}
-     * @access protected
-     * @ignore
-     */
-    _routeExpression: RegExp;
-    /**
-     * This is the list of routes the controller will define.
-     *
-     * @type {GatewayControllerRoute[]}
-     * @access protected
-     * @ignore
-     */
-    _routes: GatewayControllerRoute[];
-    /**
-     * An {@link APIClient} configuration based on the controller routes.
-     *
-     * @type {APIClientConfiguration}
-     * @access protected
-     * @ignore
-     */
-    _apiClientConfiguration: APIClientConfiguration;
-    /**
-     * A service that can have specific methods the gateway will call in order to modify
-     * requests, responses, handle errors, etc.
-     *
-     * @type {?GatewayHelperService}
-     * @access protected
-     */
-    _helperService: GatewayHelperService | null;
-    /**
-     * A dictionary of boolean flags that specify if a helper service has method. This is
-     * to avoid checking if the helper is defined and if "x method" is a function. If no
-     * helper was specified, the object will have all the flags set to `false`.
-     *
-     * @type {Object.<string, boolean>}
-     * @access protected
-     * @ignore
-     */
-    _helperServiceInfo: {
-        [x: string]: boolean;
-    };
-    /**
-     * Defines all the routes on a given router.
-     *
-     * @param {ExpressRouter}       router            The router where all the routes will
-     *                                                be added.
-     * @param {ExpressMiddleware[]} [middlewares=[]]  A list of custom middlewares that will
-     *                                                be added before the one that makes the
-     *                                                request.
-     * @returns {ExpressRouter}
-     */
-    addRoutes(router: ExpressRouter, middlewares?: ExpressMiddleware[]): ExpressRouter;
-    /**
-     * An {@link APIClient} configuration based on the controller routes.
-     *
-     * @type {APIClientConfiguration}
-     */
-    get endpointsForAPIClient(): import("../../services/http/apiClient").APIClientConfiguration;
-    /**
-     * The configuration for the API the controller will make requests to.
-     *
-     * @type {GatewayConfiguration}
-     */
-    get gatewayConfig(): GatewayConfiguration;
-    /**
-     * The options to configure how the gateway will manage the requests and the responses.
-     *
-     * @type {GatewayControllerOptions}
-     */
-    get options(): GatewayControllerOptions;
-    /**
-     * Adds a route on a given router.
-     *
-     * @param {ExpressRouter}     router              The router where the route will be
-     *                                                added.
-     * @param {string}            method              The HTTP method for the route.
-     * @param {string}            route               The path for the route.
-     * @param {ExpressMiddleware} endpointMiddleware  The middleware that makes the request.
-     * @param {Array}             middlewares         Extra middlewares to add before the
-     *                                                main one.
-     * @returns {ExpressRouter}
-     * @access protected
-     * @ignore
-     */
-    _addRoute(router: ExpressRouter, method: string, route: string, endpointMiddleware: ExpressMiddleware, middlewares: any[]): ExpressRouter;
-    /**
-     * Based on the controller options and the gateway endpoints, this method will create an
-     * API client configuration that can be used to make requests to this controller.
-     *
-     * @returns {APIClientConfiguration}
-     * @access protected
-     * @ignore
-     */
-    _createAPIClientConfiguration(): APIClientConfiguration;
-    /**
-     * Based on the information from the endpoints, this method will create the routes the
-     * controller will later add on a router.
-     *
-     * @returns {GatewayControllerRoute[]}
-     * @throws {Error} If there's more than one endpoint using the same path with the same
-     *                 HTTP method.
-     * @access protected
-     * @ignore
-     */
-    _createEndpointRoutes(): GatewayControllerRoute[];
-    /**
-     * Validates if a server helper exists and creates a dictionary with flags for all the
-     * methods a helper can have; this will allow other methods to check if the "helper
-     * method X" is available without having to check if the helper is defined and if
-     * "method X" is a function.
-     *
-     * @returns {Object.<string, boolean>}
-     * @access protected
-     * @ignore
-     */
-    _createHelperServiceInfo(): {
-        [x: string]: boolean;
-    };
-    /**
-     * Creates a regular expression the main middleware will later use in order to remove
-     * the controller route from the request url. That's needed in order to build the URL
-     * where the request will be made.
-     *
-     * @returns {RegExp}
-     * @access protected
-     * @ignore
-     */
-    _createRouteExpression(): RegExp;
-    /**
-     * Generates a middleware that will make a request and stream back the response.
-     *
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the enpdoint for which the middleware is being created.
-     * @returns {ExpressMiddleware}
-     * @access protected
-     * @ignore
-     */
-    _getMiddleware(endpoint: GatewayControllerEndpointInformation): ExpressMiddleware;
-    /**
-     * Flattens all the endpoints from gateway configuration into a one level dictionary,
-     * where the key are the paths they used to have on the original configuration, and the
-     * values are the endpoints definitions.
-     *
-     * @returns {Object.<string, string | GatewayConfigurationEndpoint>}
-     * @access protected
-     * @ignore
-     */
-    _getNormalizedEndpoints(): {
-        [x: string]: string | GatewayConfigurationEndpoint;
-    };
-    /**
-     * This method is called in order to handle a fetch request error. It will check if a
-     * helper is defined and allow it to do it, or fallback and call the next middleware.
-     *
-     * @param {Error} error
-     * The fetch request error.
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the endpoint responsible of creating the route.
-     * @param {ExpressRequest} req
-     * The server's incoming request information.
-     * @param {ExpressResponse} res
-     * The server's response information.
-     * @param {ExpressNext} next
-     * The function to call the next middleware.
-     * @returns {*}
-     * @access protected
-     * @ignore
-     */
-    _handleEndpointError(error: Error, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext): any;
-    /**
-     * This is called when the helper say that a fetch response shouldn't be sent, so the
-     * controller will allow it to handle the response by itself.
-     *
-     * @param {Object} response
-     * The response generated by the fetch request.
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the endpoint responsible of creating the route.
-     * @param {ExpressRequest} req
-     * The server's incoming request information.
-     * @param {ExpressResponse} res
-     * The server's response information.
-     * @param {ExpressNext} next
-     * The function to call the next middleware.
-     * @returns {*}
-     * @access protected
-     * @ignore
-     */
-    _handleEndpointResponse(response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext): any;
-    /**
-     * This is a helper method used in order to validate if an HTTP method can be used in
-     * order to define a route in the router. If the given method is not on the list of
-     * allowed methods,
-     * it will be "normalized" to `all`. It also transforms the method into lower case.
-     *
-     * @param {string} method  The method to validate.
-     * @returns {string}
-     * @access protected
-     * @ignore
-     */
-    _normalizeHTTPMethod(method: string): string;
-    /**
-     * Normalizes the options recevied by the controller:
-     * - Removes any trailing and leading slashes from the `root` path, if defined.
-     *
-     * @param {GatewayControllerOptions} options  The options to normalize.
-     * @returns {GatewayControllerOptions}
-     * @access protected
-     * @ignore
-     */
-    _normalizeOptions(options: GatewayControllerOptions): GatewayControllerOptions;
-    /**
-     * This method is called in order to reduce a fetch request information. It will check
-     * if a helper is defined and allow it to do it, or fallback and return the given
-     * information.
-     *
-     * @param {GatewayControllerRequest} request
-     * The information for a request the controller will make.
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the endpoint responsible of creating the route.
-     * @param {ExpressRequest} req
-     * The server's incoming request information.
-     * @param {ExpressResponse} res
-     * The server's response information.
-     * @param {ExpressNext} next
-     * The function to call the next middleware.
-     * @returns {GatewayControllerRequest}
-     * @access protected
-     * @ignore
-     */
-    _reduceEndpointRequest(request: GatewayControllerRequest, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext): GatewayControllerRequest;
-    /**
-     * This method is called in order to reduce a fetch response information. It will check
-     * if a helper is defined and allow it to do it, or fallback and return the given
-     * information.
-     *
-     * @param {Response} response
-     * The response generated by the fetch request.
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the endpoint responsible of creating the route.
-     * @param {ExpressRequest} req
-     * The server's incoming request information.
-     * @param {ExpressResponse} res
-     * The server's response information.
-     * @param {ExpressNext} next
-     * The function to call the next middleware.
-     * @returns {Response}
-     * @access protected
-     * @ignore
-     */
-    _reduceEndpointResponse(response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext): any;
-    /**
-     * This method is called in order to validate if the main middleware should pipe the
-     * fetch response stream into the server's response or if the helper will handle the
-     * response.
-     * This method will only call the helper if it implements both
-     * `shouldStreamEndpointResponse`
-     * and `handleEndpointResponse`.
-     *
-     * @param {Response} response
-     * The response generated by the fetch request.
-     * @param {GatewayControllerEndpointInformation} endpoint
-     * The information for the endpoint responsible of creating the route.
-     * @param {ExpressRequest} req
-     * The server's incoming request information.
-     * @param {ExpressResponse} res
-     * The server's response information.
-     * @param {ExpressNext} next
-     * The function to call the next middleware.
-     * @returns {boolean}
-     * @access protected
-     * @ignore
-     */
-    _shouldStreamEndpointResponse(response: any, endpoint: GatewayControllerEndpointInformation, req: ExpressRequest, res: ExpressResponse, next: ExpressNext): boolean;
-}
-/**
- * This controller allows you to have gateway routes that actually make requests and
- * respond with the contents from an specified API.
- *
- * @type {ProviderCreator<GatewayControllerCreatorOptions>}
- * @parent module:controllers
- */
-export const gatewayController: ProviderCreator<GatewayControllerCreatorOptions>;