@velajs/vela 1.19.0 → 1.19.1

package/dist/exceptions/reporter.d.ts

@@ -1,21 +0,0 @@
-import { type Catalog, type ErrorBodyResult } from '@velajs/errors';
-import type { Container } from '../container/container';
-import { type ErrorReportContext } from './exception-handler';
-/**
- * The resolved reporting facade every transport edge (HTTP, WS, live, queue,
- * schedule) uses. `report` is fire-and-forget and fully contained — a broken
- * or throwing handler can never mask the original error. `render` gives a
- * handler the chance to override the client-bound response.
- */
-export interface ErrorReporter {
-    catalog: Catalog<string>;
-    report(error: unknown, ctx: ErrorReportContext): void;
-    render(error: unknown, executionCtx: unknown): Response | ErrorBodyResult | undefined;
-}
-/**
- * Build an {@link ErrorReporter} from a container. Reads the optional
- * {@link APP_EXCEPTION_HANDLER} and {@link ERROR_CATALOG} providers; with
- * neither registered the reporter logs (unless diagnostics is `'silent'`) and
- * exposes the core catalog.
- */
-export declare const resolveErrorReporter: (container: Container) => ErrorReporter;

package/dist/exceptions/reporter.js

@@ -1,70 +0,0 @@
-import { CORE_CATALOG, isVelaError } from "@velajs/errors";
-import { HTTPException } from "hono/http-exception";
-import { HttpException } from "../errors/http-exception.js";
-import { APP_EXCEPTION_HANDLER, ERROR_CATALOG } from "../pipeline/tokens.js";
-import { matchesAny } from "./exception-handler.js";
-/**
- * Build an {@link ErrorReporter} from a container. Reads the optional
- * {@link APP_EXCEPTION_HANDLER} and {@link ERROR_CATALOG} providers; with
- * neither registered the reporter logs (unless diagnostics is `'silent'`) and
- * exposes the core catalog.
- */ export const resolveErrorReporter = (container)=>{
-    const handler = container.has(APP_EXCEPTION_HANDLER) ? container.resolve(APP_EXCEPTION_HANDLER) : undefined;
-    const catalog = container.has(ERROR_CATALOG) ? container.resolve(ERROR_CATALOG) : CORE_CATALOG;
-    return {
-        catalog,
-        report (error, ctx) {
-            let suppressed = false;
-            try {
-                suppressed = matchesAny(handler?.dontReport, error);
-            } catch  {
-            // A broken matcher must never mask the original error — treat as no match.
-            }
-            if (suppressed) return;
-            const merged = handler?.context ? {
-                ...ctx,
-                ...safeContext(handler, error, ctx)
-            } : ctx;
-            if (handler?.report) {
-                try {
-                    void Promise.resolve(handler.report(error, merged)).catch(()=>{});
-                } catch  {
-                // A broken reporter must never mask the original error.
-                }
-                return;
-            }
-            if (container.getDiagnostics() !== 'silent') {
-                const status = clientFaultStatus(error);
-                if (status !== undefined && status >= 400 && status < 500) return; // client fault — not server-error log noise
-                console.error(`[vela] ${merged.edge} error${merged.source ? ` in ${merged.source}` : ''}${merged.note ? ` (${merged.note})` : ''}:`, error);
-            }
-        },
-        render (error, executionCtx) {
-            try {
-                return handler?.render?.(error, executionCtx);
-            } catch  {
-                return undefined; // broken render hook falls through to default render
-            }
-        }
-    };
-};
-/**
- * The HTTP status of a client-fault (4xx) error, read across the three shapes a
- * caught error can take: a branded {@link VelaError} (`.status`), vela's own
- * {@link HttpException} (`getStatus()`), or hono's {@link HTTPException}
- * (`.status`). `undefined` for anything else — including raw/unbranded errors,
- * which must always be logged. Only the DEFAULT console reporter uses this to
- * mute client faults; a custom `handler.report` still receives everything.
- */ const clientFaultStatus = (error)=>{
-    if (isVelaError(error)) return error.status;
-    if (error instanceof HttpException) return error.getStatus();
-    if (error instanceof HTTPException) return error.status; // hono
-    return undefined;
-};
-const safeContext = (handler, error, ctx)=>{
-    try {
-        return handler.context?.(error, ctx) ?? {};
-    } catch  {
-        return {};
-    }
-};

package/dist/factory/adapter.d.ts

@@ -1,36 +0,0 @@
-import type { MiddlewareHandler } from 'hono';
-import type { VelaApplication } from '../application';
-import type { Container } from '../container/container';
-import type { DiscoveryService } from '../discovery/discovery.service';
-import type { RouteManager } from '../http/route.manager';
-/** The framework's resolved world, handed to adapter hooks. */
-export interface AdapterContext {
-    app: VelaApplication;
-    container: Container;
-    routeManager: RouteManager;
-    discovery: DiscoveryService;
-}
-/**
- * The contract a runtime binding implements to plug a platform into a Vela
- * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
- * the Node/Bun WebSocket transport do, made first-class:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, {
- *   adapters: [cloudflareAdapter({ bindings })],
- * });
- * ```
- *
- * - `requestMiddleware` is prepended to the global middleware chain (runs
- *   before consumer middleware — e.g. capture `c.env` for binding services).
- * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
- *   available, BEFORE routes are built — register platform services here.
- * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
- *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
- */
-export interface RuntimeAdapter {
-    name: string;
-    requestMiddleware?: MiddlewareHandler[];
-    onBootstrap?(ctx: AdapterContext): void | Promise<void>;
-    onRoutesBuilt?(ctx: AdapterContext): void | Promise<void>;
-}

package/dist/factory/adapter.js

@@ -1,18 +0,0 @@
-/**
- * The contract a runtime binding implements to plug a platform into a Vela
- * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
- * the Node/Bun WebSocket transport do, made first-class:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, {
- *   adapters: [cloudflareAdapter({ bindings })],
- * });
- * ```
- *
- * - `requestMiddleware` is prepended to the global middleware chain (runs
- *   before consumer middleware — e.g. capture `c.env` for binding services).
- * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
- *   available, BEFORE routes are built — register platform services here.
- * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
- *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
- */ export { };

package/dist/factory/bootstrap.d.ts

@@ -1,23 +0,0 @@
-import { Container } from '../container/container';
-import type { Diagnostics, Type } from '../container/types';
-import { RouteManager } from '../http/route.manager';
-import type { RouteManagerOptions } from '../http/route.manager';
-import { ModuleLoader } from '../module/module-loader';
-export interface BootstrapOptions extends RouteManagerOptions {
-    diagnostics?: Diagnostics;
-}
-export interface BootstrapResult {
-    container: Container;
-    routeManager: RouteManager;
-    loader: ModuleLoader;
-}
-/**
- * Wire the DI graph for `rootModule` and prepare the route manager — without
- * running lifecycle hooks or building the Hono app. The single primitive
- * shared by `VelaFactory.create` (HTTP), `@velajs/testing` (test), and any
- * non-HTTP consumer (CLI tools, custom runtimes).
- *
- * Framework-internal tokens (`Container`, `ModuleRef`, `APP_*`) are marked
- * global so they are resolvable from any module.
- */
-export declare function bootstrap(rootModule: Type, options?: BootstrapOptions): Promise<BootstrapResult>;

package/dist/factory/bootstrap.js

@@ -1,110 +0,0 @@
-import { Scope } from "../constants.js";
-import { Container } from "../container/container.js";
-import { ModuleRef } from "../container/module-ref.js";
-import { DiscoveryService } from "../discovery/discovery.service.js";
-import { REQUEST_CONTEXT } from "../http/request-context.js";
-import { RouteManager } from "../http/route.manager.js";
-import { UrlGeneratorService } from "../http/url/url-generator.service.js";
-import { SignedUrlGuard } from "../http/url/signed-url.guard.js";
-import { ModuleLoader } from "../module/module-loader.js";
-import { bindAppProviders } from "../pipeline/app-providers.js";
-import { APP_EXCEPTION_HANDLER, APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE, ERROR_CATALOG } from "../pipeline/tokens.js";
-/**
- * Wire the DI graph for `rootModule` and prepare the route manager — without
- * running lifecycle hooks or building the Hono app. The single primitive
- * shared by `VelaFactory.create` (HTTP), `@velajs/testing` (test), and any
- * non-HTTP consumer (CLI tools, custom runtimes).
- *
- * Framework-internal tokens (`Container`, `ModuleRef`, `APP_*`) are marked
- * global so they are resolvable from any module.
- */ export async function bootstrap(rootModule, options = {}) {
-    const container = new Container({
-        diagnostics: options.diagnostics
-    });
-    container.register({
-        provide: Container,
-        useValue: container
-    });
-    container.markGlobalToken(Container);
-    container.register({
-        provide: ModuleRef,
-        useFactory: (c)=>new ModuleRef(c),
-        inject: [
-            Container
-        ]
-    });
-    container.markGlobalToken(ModuleRef);
-    // Decorator-driven discovery — global so any provider can inject it.
-    container.register({
-        provide: DiscoveryService,
-        useFactory: (c)=>new DiscoveryService(c),
-        inject: [
-            Container
-        ]
-    });
-    container.markGlobalToken(DiscoveryService);
-    for (const t of [
-        APP_GUARD,
-        APP_PIPE,
-        APP_INTERCEPTOR,
-        APP_FILTER,
-        APP_MIDDLEWARE,
-        APP_EXCEPTION_HANDLER,
-        ERROR_CATALOG
-    ]){
-        container.markGlobalToken(t);
-    }
-    // REQUEST_CONTEXT is seeded into each request-scoped child by RouteManager
-    // before any handler resolves it (see route.manager.ts:getRequestContainer).
-    // The factory throws so misuse outside the request path surfaces immediately
-    // instead of materializing a phantom context.
-    container.register({
-        provide: REQUEST_CONTEXT,
-        scope: Scope.REQUEST,
-        useFactory: ()=>{
-            throw new Error('REQUEST_CONTEXT can only be resolved inside a request — ' + 'it is seeded by RouteManager when the request enters the pipeline.');
-        }
-    });
-    container.markGlobalToken(REQUEST_CONTEXT);
-    const routeManager = new RouteManager(container, options);
-    // Resolvable so non-HTTP transports (the WebSocket dispatcher) can read the
-    // same global-tier components (APP_* + app.useGlobalX()).
-    container.register({
-        provide: RouteManager,
-        useValue: routeManager
-    });
-    container.markGlobalToken(RouteManager);
-    // Named-route URL generation + signed-URL verification are app-level
-    // singletons: injectable from any module, and (for the guard) instantiable by
-    // the pipeline when a route opts in via `@SignedUrl()`. Both read their secret
-    // lazily and never force controllers/lazy modules to materialize.
-    container.register(UrlGeneratorService);
-    container.markGlobalToken(UrlGeneratorService);
-    container.register(SignedUrlGuard);
-    container.markGlobalToken(SignedUrlGuard);
-    const loader = new ModuleLoader(container, routeManager);
-    // loader.load() also arms the deferred-init seam (LazyModuleManager) — kept
-    // inside the loader so hand-rolled bootstrap paths that never call this
-    // function (@velajs/testing's TestingModuleBuilder.compile) get identical
-    // lazy semantics.
-    loader.load(rootModule);
-    bindAppProviders(routeManager, container, loader);
-    routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
-    if (options.globalPrefix) {
-        routeManager.setGlobalPrefix(options.globalPrefix);
-    }
-    for (const handler of options.middleware ?? []){
-        const mw = {
-            use: handler
-        };
-        routeManager.useGlobalMiddleware(mw);
-    }
-    // All providers are registered — compute request-scope bubbling so effective
-    // scopes are known before eager instantiation and request resolution.
-    container.computeEffectiveScopes();
-    return {
-        container,
-        routeManager,
-        loader
-    };
-}

package/dist/factory.d.ts

@@ -1,16 +0,0 @@
-import { VelaApplication } from './application';
-import type { Type } from './container/types';
-import type { RuntimeAdapter } from './factory/adapter';
-import type { BootstrapOptions } from './factory/bootstrap';
-export interface VelaCreateOptions extends BootstrapOptions {
-    /**
-     * Runtime adapters binding this app to a platform (Cloudflare bindings,
-     * WebSocket transports, …). Their `requestMiddleware` is prepended to the
-     * global middleware chain; `onBootstrap`/`onRoutesBuilt` hooks run around
-     * route building. See {@link RuntimeAdapter}.
-     */
-    adapters?: RuntimeAdapter[];
-}
-export declare const VelaFactory: {
-    create(rootModule: Type, options?: VelaCreateOptions): Promise<VelaApplication>;
-};

package/dist/factory.js

@@ -1,36 +0,0 @@
-import { VelaApplication } from "./application.js";
-import { DiscoveryService } from "./discovery/discovery.service.js";
-import { bootstrap } from "./factory/bootstrap.js";
-export const VelaFactory = {
-    async create (rootModule, options = {}) {
-        const { adapters = [], ...bootstrapOptions } = options;
-        const adapterMiddleware = adapters.flatMap((a)=>a.requestMiddleware ?? []);
-        if (adapterMiddleware.length > 0) {
-            bootstrapOptions.middleware = [
-                ...adapterMiddleware,
-                ...bootstrapOptions.middleware ?? []
-            ];
-        }
-        const { container, routeManager, loader } = await bootstrap(rootModule, bootstrapOptions);
-        const app = new VelaApplication(container, routeManager);
-        const instances = await loader.resolveAllInstances();
-        app.setInstances(instances);
-        await app.callOnModuleInit();
-        await app.callOnApplicationBootstrap();
-        const adapterContext = {
-            app,
-            container,
-            routeManager,
-            discovery: container.resolve(DiscoveryService)
-        };
-        for (const adapter of adapters){
-            await adapter.onBootstrap?.(adapterContext);
-        }
-        // Build routes (async — supports route-contributor integration)
-        await app.initRoutes();
-        for (const adapter of adapters){
-            await adapter.onRoutesBuilt?.(adapterContext);
-        }
-        return app;
-    }
-};

package/dist/fetch/fetch.module.d.ts

@@ -1,7 +0,0 @@
-import type { HttpModuleOptions } from './fetch.types';
-declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<HttpModuleOptions, "forRoot", "create", {
-    isGlobal?: boolean;
-}>;
-export declare class HttpModule extends ConfigurableModuleClass {
-}
-export {};

package/dist/fetch/fetch.module.js

@@ -1,31 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Module } from "../module/decorators.js";
-import { ConfigurableModuleBuilder } from "../module/configurable-module.builder.js";
-import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
-const { ConfigurableModuleClass } = new ConfigurableModuleBuilder({
-    moduleName: 'Http',
-    optionsInjectionToken: HTTP_MODULE_OPTIONS
-}).build();
-export class HttpModule extends ConfigurableModuleClass {
-}
-HttpModule = _ts_decorate([
-    Module({
-        providers: [
-            // Default for bare `imports: [HttpModule]`; forRoot(options) overrides via merge.
-            {
-                provide: HTTP_MODULE_OPTIONS,
-                useValue: {}
-            },
-            HttpService
-        ],
-        exports: [
-            HttpService,
-            HTTP_MODULE_OPTIONS
-        ]
-    })
-], HttpModule);

package/dist/fetch/fetch.service.d.ts

@@ -1,24 +0,0 @@
-import { InjectionToken } from '../container/index';
-import type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';
-export declare const HTTP_MODULE_OPTIONS: InjectionToken<HttpModuleOptions>;
-export declare class HttpRequestException extends Error {
-    readonly status: number;
-    readonly statusText: string;
-    readonly response: Response;
-    constructor(status: number, statusText: string, response: Response);
-}
-export declare class HttpService {
-    private readonly baseURL;
-    private readonly defaultHeaders;
-    private readonly defaultTimeout;
-    constructor(options: HttpModuleOptions);
-    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
-    post<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
-    put<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
-    patch<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
-    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
-    head(url: string, config?: RequestConfig): Promise<HttpResponse<void>>;
-    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
-    private buildUrl;
-    private parseBody;
-}

package/dist/fetch/fetch.service.js

@@ -1,145 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Inject, Injectable, InjectionToken, Optional } from "../container/index.js";
-export const HTTP_MODULE_OPTIONS = new InjectionToken('HTTP_MODULE_OPTIONS');
-export class HttpRequestException extends Error {
-    status;
-    statusText;
-    response;
-    constructor(status, statusText, response){
-        super(`HTTP ${status} ${statusText}`), this.status = status, this.statusText = statusText, this.response = response;
-        this.name = 'HttpRequestException';
-    }
-}
-export class HttpService {
-    baseURL;
-    defaultHeaders;
-    defaultTimeout;
-    constructor(options){
-        const opts = options ?? {};
-        this.baseURL = opts.baseURL ?? '';
-        this.defaultHeaders = opts.headers ?? {};
-        this.defaultTimeout = opts.timeout;
-    }
-    get(url, config) {
-        return this.request({
-            method: 'GET',
-            url,
-            ...config
-        });
-    }
-    post(url, body, config) {
-        return this.request({
-            method: 'POST',
-            url,
-            body,
-            ...config
-        });
-    }
-    put(url, body, config) {
-        return this.request({
-            method: 'PUT',
-            url,
-            body,
-            ...config
-        });
-    }
-    patch(url, body, config) {
-        return this.request({
-            method: 'PATCH',
-            url,
-            body,
-            ...config
-        });
-    }
-    delete(url, config) {
-        return this.request({
-            method: 'DELETE',
-            url,
-            ...config
-        });
-    }
-    head(url, config) {
-        return this.request({
-            method: 'HEAD',
-            url,
-            ...config
-        });
-    }
-    async request(config) {
-        const fullUrl = this.buildUrl(config.url, config.params);
-        const headers = {
-            ...this.defaultHeaders,
-            ...config.headers
-        };
-        const init = {
-            method: config.method,
-            headers
-        };
-        if (config.body !== undefined) {
-            if (typeof config.body === 'string' || config.body instanceof FormData) {
-                init.body = config.body;
-            } else {
-                init.body = JSON.stringify(config.body);
-                if (!headers['Content-Type'] && !headers['content-type']) {
-                    headers['Content-Type'] = 'application/json';
-                }
-            }
-        }
-        const timeout = config.timeout ?? this.defaultTimeout;
-        if (timeout !== undefined) {
-            init.signal = AbortSignal.timeout(timeout);
-        }
-        const response = await fetch(fullUrl, init);
-        if (!response.ok) {
-            throw new HttpRequestException(response.status, response.statusText, response);
-        }
-        const data = await this.parseBody(response);
-        return {
-            data,
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers
-        };
-    }
-    buildUrl(url, params) {
-        const base = this.baseURL ? `${this.baseURL}${url}` : url;
-        if (!params || Object.keys(params).length === 0) return base;
-        const searchParams = new URLSearchParams(Object.entries(params).map(([k, v])=>[
-                k,
-                String(v)
-            ]));
-        return `${base}?${searchParams.toString()}`;
-    }
-    async parseBody(response) {
-        if (response.status === 204 || response.headers.get('content-length') === '0') {
-            return undefined;
-        }
-        const contentType = response.headers.get('content-type') ?? '';
-        if (contentType.includes('application/json')) {
-            return response.json();
-        }
-        return response.text();
-    }
-}
-HttpService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Optional()),
-    _ts_param(0, Inject(HTTP_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HttpModuleOptions === "undefined" ? Object : HttpModuleOptions
-    ])
-], HttpService);

package/dist/fetch/fetch.types.d.ts

@@ -1,24 +0,0 @@
-export interface HttpModuleOptions {
-    /** Base URL prepended to all requests. */
-    baseURL?: string;
-    /** Default headers sent with every request. */
-    headers?: Record<string, string>;
-    /** Default timeout in milliseconds (uses AbortSignal.timeout). */
-    timeout?: number;
-}
-export interface RequestConfig {
-    headers?: Record<string, string>;
-    params?: Record<string, string | number | boolean>;
-    timeout?: number;
-}
-export interface HttpRequestConfig extends RequestConfig {
-    method: string;
-    url: string;
-    body?: unknown;
-}
-export interface HttpResponse<T = unknown> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Headers;
-}

package/dist/fetch/fetch.types.js

@@ -1 +0,0 @@
-export { };

package/dist/fetch/index.d.ts

@@ -1,3 +0,0 @@
-export { HttpModule } from './fetch.module';
-export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from './fetch.service';
-export type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';

package/dist/fetch/index.js

@@ -1,2 +0,0 @@
-export { HttpModule } from "./fetch.module.js";
-export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from "./fetch.service.js";

package/dist/health/health.http.d.ts

@@ -1,14 +0,0 @@
-import { HealthIndicatorService } from './health.indicator';
-import type { HealthIndicatorResult, ResponseCheckCallback } from './health.types';
-export interface HttpPingOptions {
-    method?: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-    expectedStatus?: number;
-}
-export declare class HttpHealthIndicator {
-    private indicator;
-    constructor(indicator: HealthIndicatorService);
-    pingCheck(key: string, url: string, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
-    responseCheck(key: string, url: string, callback: ResponseCheckCallback, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
-}