export { CurrentConfigurationNotSetError };
export default class VelociousConfiguration {
    /**
     * Runs current.
     * @returns {VelociousConfiguration} - The current.
     */
    static current(): VelociousConfiguration;
    /**
     * Runs constructor.
     * @param {import("./configuration-types.js").ConfigurationArgsType} args - Configuration arguments.
     */
    constructor({ abilityResolver, abilityResources, attachments, autoload, backgroundJobs, backendProjects, beacon, cookieSecret, cors, database, debug, debugEndpoint, directory, enforceTenantDatabaseScopes, environment, environmentHandler, exposeInternalErrorsToClients, httpServer, initializeModels, initializers, locale, localeFallbacks, locales, logging, mailerBackend, requestTimeoutMs, routeResolverHooks, scheduledBackgroundJobs, structureSql, tenantDatabaseProviders, tenantDatabaseResolver, tenantResolver, testing, timezoneOffsetMinutes, trustedProxies, websocketChannelResolver, websocketMessageHandlerResolver, ...restArgs }: import("./configuration-types.js").ConfigurationArgsType);
    /**
     * Close database connections promise.
      @type {Promise<void> | null} */
    _closeDatabaseConnectionsPromise: Promise<void> | null;
    _abilityResolver: import("./configuration-types.js").AbilityResolverType | undefined;
    _abilityResources: typeof import("./authorization/base-resource.js").default[];
    _autoload: boolean;
    _backgroundJobs: import("./configuration-types.js").BackgroundJobsConfiguration | undefined;
    _beacon: import("./configuration-types.js").BeaconConfiguration | undefined;
    /**
     * Stores the beacon client value.
      @type {import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined} */
    _beaconClient: import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined;
    /**
     * Stores the beacon connect promise value.
      @type {Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined> | undefined} */
    _beaconConnectPromise: Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined> | undefined;
    /**
     * Stores the beacon report timer value.
     * @type {ReturnType<typeof setTimeout> | undefined} - Pending "beacon still unreachable" report timer.
     */
    _beaconReportTimer: ReturnType<typeof setTimeout> | undefined;
    /**
     * Stores the beacon outage reported value.
     * @type {boolean} - Whether the current beacon outage has already been reported.
     */
    _beaconOutageReported: boolean;
    /**
     * Stores the beacon last down error value.
     * @type {{stage: "beacon-connect" | "beacon-disconnect", error: Error} | undefined} - Latest beacon-down details, reported only if the outage is sustained.
     */
    _beaconLastDownError: {
        stage: "beacon-connect" | "beacon-disconnect";
        error: Error;
    } | undefined;
    _scheduledBackgroundJobs: import("./configuration-types.js").ScheduledBackgroundJobsConfiguration | import("./configuration-types.js").ScheduledBackgroundJobsLoaderType | undefined;
    _attachments: import("./configuration-types.js").AttachmentsConfiguration;
    _backendProjects: import("./configuration-types.js").BackendProjectConfiguration[];
    /** @type {Array<(args: {context: ?, error: Error, request: ?}) => Promise<Record<string, ?> | void> | Record<string, ?> | void>} */
    _clientErrorPayloadReporters: Array<(args: {
        context: unknown;
        error: Error;
        request: unknown;
    }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void>;
    cors: import("./configuration-types.js").CorsType | undefined;
    _cookieSecret: string | undefined;
    database: {
        [key: string]: {
            [key: string]: import("./configuration-types.js").DatabaseConfigurationType;
        };
    };
    debug: boolean;
    _debugEndpoint: {
        enabled: boolean;
        path: string;
        token: string | null;
    };
    _environment: string;
    _environmentHandler: import("./environment-handlers/base.js").default;
    _enforceTenantDatabaseScopes: boolean;
    _exposeInternalErrorsToClients: boolean;
    _directory: string | undefined;
    _initializeModels: (arg0: {
        configuration: import("./configuration.js").default;
        type: string;
    }) => void;
    _isInitialized: boolean;
    httpServer: import("./configuration-types.js").HttpServerConfiguration;
    /**
     * Stores the http server instance value.
      @type {{getDebugSnapshot: () => Promise<Record<string, ?>>} | undefined} */
    _httpServerInstance: {
        getDebugSnapshot: () => Promise<Record<string, unknown>>;
    } | undefined;
    locale: string | (() => string);
    localeFallbacks: import("./configuration-types.js").LocaleFallbacksType;
    locales: string[];
    _initializers: import("./configuration-types.js").InitializersType | undefined;
    _testing: string | undefined;
    _timezoneOffsetMinutes: number | (() => number) | undefined;
    _trustedProxies: string | string[] | undefined;
    _requestTimeoutMs: number | (() => number) | undefined;
    _structureSql: import("./configuration-types.js").StructureSqlConfiguration | undefined;
    _tenantDatabaseProviders: Record<string, import("./configuration-types.js").TenantDatabaseProviderType>;
    _tenantDatabaseResolver: import("./configuration-types.js").TenantDatabaseResolverType | undefined;
    _tenantResolver: import("./configuration-types.js").TenantResolverType | undefined;
    _websocketEvents: import("./http-server/websocket-events.js").default | undefined;
    /**
     * Stores the websocket channel subscribers value.
      @type {VelociousWebsocketChannelSubscribers | undefined} */
    _websocketChannelSubscribers: VelociousWebsocketChannelSubscribers | undefined;
    _websocketChannelResolver: import("./configuration-types.js").WebsocketChannelResolverType | undefined;
    _websocketMessageHandlerResolver: import("./configuration-types.js").WebsocketMessageHandlerResolverType | undefined;
    /**
     * Stores the websocket connection classes value.
      @type {Map<string, typeof import("./http-server/websocket-connection.js").default>} */
    _websocketConnectionClasses: Map<string, typeof import("./http-server/websocket-connection.js").default>;
    /**
     * Stores the websocket channel classes value.
      @type {Map<string, typeof import("./http-server/websocket-channel.js").default>} */
    _websocketChannelClasses: Map<string, typeof import("./http-server/websocket-channel.js").default>;
    /**
     * Stores the websocket channel subscriptions value.
     * @type {Map<string, Set<import("./http-server/websocket-channel.js").default>>} - channelType → live subscriptions across all sessions.
     */
    _websocketChannelSubscriptions: Map<string, Set<import("./http-server/websocket-channel.js").default>>;
    /**
     * Stores the websocket sessions value.
     * @type {Set<import("./http-server/client/websocket-session.js").default>} - Live websocket sessions, including paused sessions within the grace window.
     */
    _websocketSessions: Set<import("./http-server/client/websocket-session.js").default>;
    /**
     * Stores the paused websocket sessions value.
     * @type {Map<string, {session: import("./http-server/client/websocket-session.js").default, graceTimer: ReturnType<typeof setTimeout>, pausedAt: number}>} - sessionId → paused session awaiting resume.
     */
    _pausedWebsocketSessions: Map<string, {
        session: import("./http-server/client/websocket-session.js").default;
        graceTimer: ReturnType<typeof setTimeout>;
        pausedAt: number;
    }>;
    /** Grace period for paused WebSocket sessions before permanent teardown. */
    _websocketSessionGraceSeconds: number;
    /**
     * Optional wrapper called around every WebSocket-borne request /
     * connection message / channel dispatch. Apps register it here
     * to set up per-request context (e.g. AsyncLocalStorage for
     * locale, tenant, tracing) that downstream handlers read.
     * @type {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null}
     */
    _websocketAroundRequest: ((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null;
    /**
     * Stores the around action value.
      @type {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null} */
    _aroundAction: ((context: {
        request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default;
        response: import("./http-server/client/response.js").default;
        next: () => Promise<void>;
    }) => Promise<void>) | null;
    /**
     * Stores the websocket session identity resolver value.
      @type {((session: import("./http-server/client/websocket-session.js").default) => ? | Promise<?>) | null} */
    _websocketSessionIdentityResolver: ((session: import("./http-server/client/websocket-session.js").default) => unknown | Promise<unknown>) | null;
    _logging: import("./configuration-types.js").LoggingConfiguration | undefined;
    _mailerBackend: import("./configuration-types.js").MailerBackend | undefined;
    _routeResolverHooks: import("./configuration-types.js").RouteResolverHookType[];
    /**
     * Stores the applied route mounts value.
      @type {WeakSet<object>} */
    _appliedRouteMounts: WeakSet<object>;
    _errorEvents: import("eventemitter3").EventEmitter<string | symbol, any>;
    /**
     * Stores the database pools value.
      @type {{[key: string]: import("./database/pool/base.js").default}} */
    databasePools: {
        [key: string]: import("./database/pool/base.js").default;
    };
    /**
     * Stores the model classes value.
      @type {{[key: string]: typeof import("./database/record/index.js").default}} */
    modelClasses: {
        [key: string]: typeof import("./database/record/index.js").default;
    };
    /**
     * Runs get autoload.
     * @returns {boolean} Whether auto-batch-preload of relationships on lazy access is enabled globally.
     */
    getAutoload(): boolean;
    /**
     * Runs get expose internal errors to clients.
     * @returns {boolean} Whether unexpected internal error details may be returned to API clients.
     */
    getExposeInternalErrorsToClients(): boolean;
    /**
     * Runs get debug endpoint.
     * @returns {{enabled: boolean, path: string, token: string | null}} - Debug endpoint configuration.
     */
    getDebugEndpoint(): {
        enabled: boolean;
        path: string;
        token: string | null;
    };
    /**
     * Runs debug endpoint snapshot.
     * @returns {{enabled: boolean, path: string, tokenConfigured: boolean}} - Debug endpoint config for the snapshot, with the token redacted.
     */
    _debugEndpointSnapshot(): {
        enabled: boolean;
        path: string;
        tokenConfigured: boolean;
    };
    /**
     * Runs normalize debug endpoint.
     * @param {boolean | {path?: string, token?: string}} value - Debug endpoint configuration.
     * @returns {{enabled: boolean, path: string, token: string | null}} - Normalized debug endpoint configuration.
     */
    _normalizeDebugEndpoint(value: boolean | {
        path?: string;
        token?: string;
    }): {
        enabled: boolean;
        path: string;
        token: string | null;
    };
    /**
     * Runs add debug endpoint route hook.
     * @returns {void} - No return value.
     */
    _addDebugEndpointRouteHook(): void;
    /**
     * Runs set autoload.
     * @param {boolean} newValue - Whether auto-batch-preload of relationships is enabled.
     * @returns {void}
     */
    setAutoload(newValue: boolean): void;
    /**
     * Runs get cors.
     * @returns {import("./configuration-types.js").CorsType | undefined} - The cors.
     */
    getCors(): import("./configuration-types.js").CorsType | undefined;
    /**
     * Runs get cookie secret.
     * @returns {string | undefined} - Cookie secret.
     */
    getCookieSecret(): string | undefined;
    /**
     * Runs get database configuration.
     * @returns {Record<string, import("./configuration-types.js").DatabaseConfigurationType>} - The database configuration.
     */
    getDatabaseConfiguration(): Record<string, import("./configuration-types.js").DatabaseConfigurationType>;
    /**
     * Runs resolve database configuration.
     * @param {string} identifier - Identifier.
     * @param {?} [tenant] - Tenant override.
     * @returns {import("./configuration-types.js").DatabaseConfigurationType} - Resolved database configuration for the identifier.
     */
    resolveDatabaseConfiguration(identifier: string, tenant?: unknown): import("./configuration-types.js").DatabaseConfigurationType;
    /**
     * Runs get disabled database identifiers.
     * @returns {Set<string>} - Disabled database identifiers from env flags.
     */
    getDisabledDatabaseIdentifiers(): Set<string>;
    /**
     * Runs is database identifier active.
     * @param {string} identifier - Database identifier.
     * @param {?} [tenant] - Tenant override.
     * @returns {boolean} - Whether this database identifier is active in the current tenant context.
     */
    isDatabaseIdentifierActive(identifier: string, tenant?: unknown): boolean;
    /**
     * Runs get database identifiers.
     * @returns {Array<string>} - The database identifiers.
     */
    getDatabaseIdentifiers(): Array<string>;
    /**
     * Runs get debug snapshot.
     * @returns {Promise<Record<string, ?>>} - Human-readable server diagnostics.
     */
    getDebugSnapshot(): Promise<Record<string, unknown>>;
    /**
     * Runs get local debug snapshot.
     * @returns {Record<string, ?>} - Human-readable diagnostics for this process only.
     */
    getLocalDebugSnapshot(): Record<string, unknown>;
    /**
     * Runs debug http server snapshot.
     * @returns {Promise<Record<string, ?>>} - HTTP server worker diagnostics.
     */
    _debugHttpServerSnapshot(): Promise<Record<string, unknown>>;
    /**
     * Runs debug server snapshot.
     * @returns {Record<string, ?>} - Server runtime diagnostics.
     */
    _debugServerSnapshot(): Record<string, unknown>;
    /**
     * Runs debug configuration snapshot.
     * @returns {Record<string, ?>} - Configuration diagnostics.
     */
    _debugConfigurationSnapshot(): Record<string, unknown>;
    /**
     * Runs debug background jobs snapshot.
     * @returns {Record<string, ?>} - Background job diagnostics.
     */
    _debugBackgroundJobsSnapshot(): Record<string, unknown>;
    /**
     * Runs debug database snapshot.
     * @returns {Record<string, ?>} - Database diagnostics.
     */
    _debugDatabaseSnapshot(): Record<string, unknown>;
    /**
     * Runs debug websocket snapshot.
     * @returns {Record<string, ?>} - WebSocket diagnostics.
     */
    _debugWebsocketSnapshot(): Record<string, unknown>;
    /**
     * Runs get database pool.
     * @param {string} identifier - Identifier.
     * @returns {import("./database/pool/base.js").default} - The database pool.
     */
    getDatabasePool(identifier?: string): import("./database/pool/base.js").default;
    /**
     * Runs get database identifier.
     * @param {string} identifier - Identifier.
     * @returns {import("./configuration-types.js").DatabaseConfigurationType})
     */
    getDatabaseIdentifier(identifier: string): import("./configuration-types.js").DatabaseConfigurationType;
    /**
     * Clears the schema metadata cached by every initialized pool that targets the
     * same physical database (matched by connection reuse key). Separate pools that
     * point at one database keep independent schema caches, so DDL run through one
     * pool would otherwise leave the others reporting stale tables/columns.
     * @param {string} reuseKey - Connection reuse key identifying the shared database.
     * @returns {void} - No return value.
     */
    clearSchemaCachesForReuseKey(reuseKey: string): void;
    /**
     * Runs get database pool type.
     * @param {string} identifier - Identifier.
     * @returns {typeof import("./database/pool/base.js").default} - The database pool type.
     */
    getDatabasePoolType(identifier?: string): typeof import("./database/pool/base.js").default;
    getDatabaseType(identifier?: string): "sqlite" | "pgsql" | "mysql" | "mssql";
    /**
     * Runs get directory.
     * @returns {string} - The directory.
     */
    getDirectory(): string;
    /**
     * Runs get directory if available.
     * @returns {string | undefined} - The directory when the runtime can resolve one.
     */
    getDirectoryIfAvailable(): string | undefined;
    /**
     * Runs get backend projects.
     * @returns {import("./configuration-types.js").BackendProjectConfiguration[]} - Backend projects.
     */
    getBackendProjects(): import("./configuration-types.js").BackendProjectConfiguration[];
    /**
     * Runs get ability resources.
     * @returns {import("./configuration-types.js").AbilityResourceClassType[]} - Ability resource classes.
     */
    getAbilityResources(): import("./configuration-types.js").AbilityResourceClassType[];
    /**
     * Runs set ability resources.
     * @param {import("./configuration-types.js").AbilityResourceClassType[]} resources - Ability resource classes.
     * @returns {void} - No return value.
     */
    setAbilityResources(resources: import("./configuration-types.js").AbilityResourceClassType[]): void;
    /**
     * Runs get ability resolver.
     * @returns {import("./configuration-types.js").AbilityResolverType | undefined} - Ability resolver.
     */
    getAbilityResolver(): import("./configuration-types.js").AbilityResolverType | undefined;
    /**
     * Runs get tenant resolver.
     * @returns {import("./configuration-types.js").TenantResolverType | undefined} - Tenant resolver.
     */
    getTenantResolver(): import("./configuration-types.js").TenantResolverType | undefined;
    /**
     * Runs get tenant database resolver.
     * @returns {import("./configuration-types.js").TenantDatabaseResolverType | undefined} - Tenant database resolver.
     */
    getTenantDatabaseResolver(): import("./configuration-types.js").TenantDatabaseResolverType | undefined;
    /**
     * Runs get enforce tenant database scopes.
     * @returns {boolean} - Whether tenant-switched models require a resolved tenant database identifier.
     */
    getEnforceTenantDatabaseScopes(): boolean;
    /**
     * Runs get tenant database providers.
     * @returns {Record<string, import("./configuration-types.js").TenantDatabaseProviderType>} - Tenant database lifecycle providers.
     */
    getTenantDatabaseProviders(): Record<string, import("./configuration-types.js").TenantDatabaseProviderType>;
    /**
     * Runs get tenant database provider.
     * @param {string} identifier - Database identifier.
     * @returns {import("./configuration-types.js").TenantDatabaseProviderType} - Tenant database lifecycle provider.
     */
    getTenantDatabaseProvider(identifier: string): import("./configuration-types.js").TenantDatabaseProviderType;
    /**
     * Runs get attachments configuration.
     * @returns {import("./configuration-types.js").AttachmentsConfiguration} - Attachments configuration.
     */
    getAttachmentsConfiguration(): import("./configuration-types.js").AttachmentsConfiguration;
    /**
     * Runs get route resolver hooks.
     * @returns {import("./configuration-types.js").RouteResolverHookType[]} - Route resolver hooks.
     */
    getRouteResolverHooks(): import("./configuration-types.js").RouteResolverHookType[];
    /**
     * Runs add route resolver hook.
     * @param {import("./configuration-types.js").RouteResolverHookType} hook - Route resolver hook.
     * @returns {void} - No return value.
     */
    addRouteResolverHook(hook: import("./configuration-types.js").RouteResolverHookType): void;
    /**
     * Runs set ability resolver.
     * @param {import("./configuration-types.js").AbilityResolverType | undefined} resolver - Ability resolver.
     * @returns {void} - No return value.
     */
    setAbilityResolver(resolver: import("./configuration-types.js").AbilityResolverType | undefined): void;
    /**
     * Runs set tenant resolver.
     * @param {import("./configuration-types.js").TenantResolverType | undefined} resolver - Tenant resolver.
     * @returns {void} - No return value.
     */
    setTenantResolver(resolver: import("./configuration-types.js").TenantResolverType | undefined): void;
    /**
     * Runs set tenant database resolver.
     * @param {import("./configuration-types.js").TenantDatabaseResolverType | undefined} resolver - Tenant database resolver.
     * @returns {void} - No return value.
     */
    setTenantDatabaseResolver(resolver: import("./configuration-types.js").TenantDatabaseResolverType | undefined): void;
    /**
     * Runs set enforce tenant database scopes.
     * @param {boolean} newValue - Whether tenant-switched models require a resolved tenant database identifier.
     * @returns {void} - No return value.
     */
    setEnforceTenantDatabaseScopes(newValue: boolean): void;
    /**
     * Runs set tenant database providers.
     * @param {Record<string, import("./configuration-types.js").TenantDatabaseProviderType>} providers - Tenant database lifecycle providers.
     * @returns {void} - No return value.
     */
    setTenantDatabaseProviders(providers: Record<string, import("./configuration-types.js").TenantDatabaseProviderType>): void;
    /**
     * Runs get environment.
     * @returns {string} - The environment.
     */
    getEnvironment(): string;
    /**
     * Runs get request timeout ms.
     * @returns {number} - Request timeout in seconds.
     */
    getRequestTimeoutMs(): number;
    /**
     * Runs parse request timeout seconds.
     * @param {string | undefined} rawValue - Env value.
     * @returns {number | undefined} - Timeout in seconds.
     */
    _parseRequestTimeoutSeconds(rawValue: string | undefined): number | undefined;
    /**
     * Runs set environment.
     * @param {string} newEnvironment - New environment.
     * @returns {void} - No return value.
     */
    setEnvironment(newEnvironment: string): void;
    /**
     * Runs get logging configuration.
     * @param {object} [args] - Options object.
     * @param {boolean} [args.defaultConsole] - Whether default console.
     * @returns {Required<Pick<import("./configuration-types.js").LoggingConfiguration, "console" | "file" | "levels">> & Pick<import("./configuration-types.js").LoggingConfiguration, "directory" | "filePath"> & Partial<Pick<import("./configuration-types.js").LoggingConfiguration, "outputs" | "loggers">>} - The logging configuration.
     */
    getLoggingConfiguration({ defaultConsole }?: {
        defaultConsole?: boolean | undefined;
    }): Required<Pick<import("./configuration-types.js").LoggingConfiguration, "console" | "file" | "levels">> & Pick<import("./configuration-types.js").LoggingConfiguration, "directory" | "filePath"> & Partial<Pick<import("./configuration-types.js").LoggingConfiguration, "outputs" | "loggers">>;
    /**
     * Runs get query logging enabled.
     * @returns {boolean} - Whether database query logging is enabled.
     */
    getQueryLoggingEnabled(): boolean;
    /**
     * Runs get background jobs config.
     * @returns {Required<import("./configuration-types.js").BackgroundJobsConfiguration>} - Background jobs configuration.
     */
    getBackgroundJobsConfig(): Required<import("./configuration-types.js").BackgroundJobsConfiguration>;
    /**
     * Runs set background jobs config.
     * @param {import("./configuration-types.js").BackgroundJobsConfiguration} backgroundJobs - Background jobs config.
     * @returns {void}
     */
    setBackgroundJobsConfig(backgroundJobs: import("./configuration-types.js").BackgroundJobsConfiguration): void;
    /**
     * Resolves the active Beacon configuration. Beacon is opt-in: it
     * stays disabled unless the app passes `beacon: {host, port}` /
     * `beacon: {inProcess: true}`, calls `setBeaconConfig({...})`, or
     * sets the `VELOCIOUS_BEACON_HOST` / `VELOCIOUS_BEACON_PORT` env vars.
     * Setting `enabled: false` explicitly disables it even when env vars
     * are present (useful for tests). When `inProcess: true` is set,
     * env-var host/port are ignored — code-level config wins.
     * @returns {{enabled: boolean, host: string, port: number, peerType?: string, inProcess: boolean, unreachableReportMs: number}} - Beacon configuration with defaults applied.
     */
    getBeaconConfig(): {
        enabled: boolean;
        host: string;
        port: number;
        peerType?: string;
        inProcess: boolean;
        unreachableReportMs: number;
    };
    /**
     * Runs set beacon config.
     * @param {import("./configuration-types.js").BeaconConfiguration} beacon - Beacon config.
     * @returns {void}
     */
    setBeaconConfig(beacon: import("./configuration-types.js").BeaconConfiguration): void;
    /**
     * Runs get beacon client.
     * @returns {import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined} - The active Beacon client, if connected.
     */
    getBeaconClient(): import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined;
    /**
     * Connects this configuration's Beacon client to the configured
     * broker, wiring incoming broadcasts to the local delivery path so
     * any websocket subscribers in this process receive them. Idempotent
     * — repeat calls return the same in-flight or resolved promise.
     *
     * Returns immediately with `undefined` if Beacon is not enabled.
     *
     * **Non-blocking by design (TCP mode).** For broker-backed Beacon, the
     * returned promise resolves as soon as the client is constructed and
     * the TCP connect is launched — it does **not** wait for the connect
     * handshake to complete. A broker that silently drops SYNs
     * (firewall/NACL DROP rules) would otherwise block startup on the OS
     * TCP connect timeout (tens of seconds), which contradicts the
     * documented "fall back to local-only and reconnect in the
     * background" contract. Initial-connect failures surface
     * asynchronously on the framework-error channel via the
     * `connect-error` listener registered here. Callers that need a
     * deterministic publish-readiness boundary should call
     * `getBeaconClient()?.waitForReady({timeoutMs})`.
     *
     * **In-process mode** awaits `connect()` — that path is synchronous,
     * cannot fail, and gives callers predictable readiness.
     * @param {object} [args] - Options.
     * @param {string} [args.peerType] - Override peerType for this connect call (e.g. `"server"`, `"background-jobs-worker"`).
     * @returns {Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined>} - Resolves with the registered client (TCP mode: connect may still be in flight), or undefined when Beacon is disabled.
     */
    connectBeacon({ peerType }?: {
        peerType?: string | undefined;
    }): Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default | undefined>;
    /**
     * Builds a Beacon client matching the configured mode. Split out so
     * `connectBeacon` stays focused on lifecycle and error wiring.
     * @param {object} args - Options.
     * @param {ReturnType<VelociousConfiguration["getBeaconConfig"]>} args.config - Resolved Beacon config.
     * @param {string} [args.peerType] - Resolved peer type.
     * @returns {Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default>} - Beacon client.
     */
    _createBeaconClient({ config, peerType }: {
        config: ReturnType<VelociousConfiguration["getBeaconConfig"]>;
        peerType?: string | undefined;
    }): Promise<import("./beacon/client.js").default | import("./beacon/in-process-client.js").default>;
    /**
     * Records a Beacon connect/disconnect failure without reporting it immediately.
     * The BeaconClient auto-reconnects, so brief outages (e.g. a deploy restarting
     * the broker) are expected; only if the beacon is still unreachable after
     * `reportAfterMs` is a single framework-error surfaced via `_reportBeaconError`.
     * A subsequent `connect` (see `_handleBeaconUp`) cancels the pending report.
     * @param {object} args - Options.
     * @param {"beacon-connect" | "beacon-disconnect"} args.stage - Failure stage.
     * @param {Error} args.error - Error instance.
     * @param {number} args.reportAfterMs - Grace window before a sustained outage is reported.
     * @returns {void}
     */
    _handleBeaconDown({ stage, error, reportAfterMs }: {
        stage: "beacon-connect" | "beacon-disconnect";
        error: Error;
        reportAfterMs: number;
    }): void;
    /**
     * Clears beacon-down state on a (re)connect. A blip that recovers within the
     * grace window is never reported; if a sustained outage had already been
     * reported, the state resets so a future outage can report again.
     * @returns {void}
     */
    _handleBeaconUp(): void;
    /**
     * Surfaces a Beacon failure on the framework error channel. Mirrors
     * the pattern used by `request-runner.js` for HTTP errors. When no
     * listener is attached to either `framework-error` or `all-error`,
     * also schedules an unhandled promise rejection so process-level bug
     * reporters (which subscribe to `unhandledRejection` by default) pick
     * the failure up — and ALSO writes a one-line summary to `stderr` so
     * the failure isn't completely silent on Node 24+ where the default
     * behavior of `unhandledRejection` is to terminate the process. An
     * app that sees its server suddenly exit needs at least one
     * breadcrumb in the logs to know Beacon was the cause; the previous
     * behavior left a stack-only crash with no context tying it back to
     * the broker.
     * @param {object} args - Options.
     * @param {"beacon-connect" | "beacon-disconnect"} args.stage - Failure stage.
     * @param {Error} args.error - Error instance.
     * @returns {void}
     */
    _reportBeaconError({ stage, error }: {
        stage: "beacon-connect" | "beacon-disconnect";
        error: Error;
    }): void;
    /**
     * Closes the active Beacon client (if any). Safe to call multiple
     * times.
     * @returns {Promise<void>}
     */
    disconnectBeacon(): Promise<void>;
    /**
     * Routes a Beacon-sourced broadcast through the same delivery code
     * path as a locally-originated one. Prefers the workerthread-aware
     * `broadcastV2` when an HTTP server is hosting workers, and falls
     * back to the per-process subscription dispatch otherwise.
     * @param {import("./beacon/types.js").BeaconBroadcastMessage} message - Broadcast message.
     * @returns {void}
     */
    _deliverBroadcastFromBeacon(message: import("./beacon/types.js").BeaconBroadcastMessage): void;
    /**
     * Runs get scheduled background jobs config.
     * @returns {Promise<import("./configuration-types.js").ScheduledBackgroundJobsConfiguration | undefined>} - Scheduled background jobs configuration.
     */
    getScheduledBackgroundJobsConfig(): Promise<import("./configuration-types.js").ScheduledBackgroundJobsConfiguration | undefined>;
    /**
     * Runs set scheduled background jobs config.
     * @param {import("./configuration-types.js").ScheduledBackgroundJobsConfiguration | import("./configuration-types.js").ScheduledBackgroundJobsLoaderType | undefined} scheduledBackgroundJobs - Scheduled background jobs configuration.
     * @returns {void}
     */
    setScheduledBackgroundJobsConfig(scheduledBackgroundJobs: import("./configuration-types.js").ScheduledBackgroundJobsConfiguration | import("./configuration-types.js").ScheduledBackgroundJobsLoaderType | undefined): void;
    /**
     * Runs get mailer backend.
     * @returns {import("./configuration-types.js").MailerBackend | undefined} - Mailer backend.
     */
    getMailerBackend(): import("./configuration-types.js").MailerBackend | undefined;
    /**
     * Runs set mailer backend.
     * @param {import("./configuration-types.js").MailerBackend} mailerBackend - Mailer backend.
     * @returns {void} - No return value.
     */
    setMailerBackend(mailerBackend: import("./configuration-types.js").MailerBackend): void;
    /**
     * Logging configuration tailored for HTTP request logging. Defaults console logging to true and applies the user `logging.console` flag only for request logging.
     * @returns {Required<Pick<import("./configuration-types.js").LoggingConfiguration, "console" | "file" | "levels">> & Pick<import("./configuration-types.js").LoggingConfiguration, "directory" | "filePath"> & Partial<Pick<import("./configuration-types.js").LoggingConfiguration, "outputs" | "loggers">>} - The http logging configuration.
     */
    getHttpLoggingConfiguration(): Required<Pick<import("./configuration-types.js").LoggingConfiguration, "console" | "file" | "levels">> & Pick<import("./configuration-types.js").LoggingConfiguration, "directory" | "filePath"> & Partial<Pick<import("./configuration-types.js").LoggingConfiguration, "outputs" | "loggers">>;
    /**
     * Runs get environment handler.
     * @returns {import("./environment-handlers/base.js").default} - The environment handler.
     */
    getEnvironmentHandler(): import("./environment-handlers/base.js").default;
    /**
     * Runs get locale fallbacks.
     * @returns {import("./configuration-types.js").LocaleFallbacksType | undefined} - The locale fallbacks.
     */
    getLocaleFallbacks(): import("./configuration-types.js").LocaleFallbacksType | undefined;
    /**
     * Runs set locale fallbacks.
     * @param {import("./configuration-types.js").LocaleFallbacksType} newLocaleFallbacks - New locale fallbacks.
     * @returns {void} - No return value.
     */
    setLocaleFallbacks(newLocaleFallbacks: import("./configuration-types.js").LocaleFallbacksType): void;
    /**
     * Runs get structure sql config.
     * @returns {import("./configuration-types.js").StructureSqlConfiguration | undefined} - Structure SQL config.
     */
    getStructureSqlConfig(): import("./configuration-types.js").StructureSqlConfiguration | undefined;
    /**
     * Runs should write structure sql.
     * @param {{reason?: "migration" | "schemaDump"}} [args] - Call context for the structure sql write decision.
     * @returns {boolean} - Whether structure SQL files should be generated for the current environment.
     */
    shouldWriteStructureSql(args?: {
        reason?: "migration" | "schemaDump";
    }): boolean;
    /**
     * Runs set structure sql config.
     * @param {import("./configuration-types.js").StructureSqlConfiguration} structureSql - Structure SQL config.
     * @returns {void} - No return value.
     */
    setStructureSqlConfig(structureSql: import("./configuration-types.js").StructureSqlConfiguration): void;
    /**
     * Runs get locale.
     * @returns {string} - The locale.
     */
    getLocale(): string;
    /**
     * Runs get locales.
     * @returns {Array<string>} - The locales.
     */
    getLocales(): Array<string>;
    /**
     * Runs get model class.
     * @param {string} name - Name.
     * @returns {typeof import("./database/record/index.js").default} - The model class.
     */
    getModelClass(name: string): typeof import("./database/record/index.js").default;
    /**
     * Runs get model classes.
     * @returns {Record<string, typeof import("./database/record/index.js").default>} A hash of all model classes, keyed by model name, as they were defined in the configuration. This is a direct reference to the model classes, not a copy.
     */
    getModelClasses(): Record<string, typeof import("./database/record/index.js").default>;
    /**
     * Runs get testing.
     * @returns {string | undefined} The path to a config file that should be used for testing.
     */
    getTesting(): string | undefined;
    /**
     * Runs get trusted proxies.
     * @returns {string | string[] | undefined} Trusted reverse proxy address ranges.
     */
    getTrustedProxies(): string | string[] | undefined;
    /**
     * Runs set trusted proxies.
     * @param {string | string[] | undefined} trustedProxies - Trusted reverse proxy address ranges.
     * @returns {void}
     */
    setTrustedProxies(trustedProxies: string | string[] | undefined): void;
    /**
     * Runs initialize database pool.
     * @param {string} [identifier] - Database identifier to initialize.
     * @returns {void} - No return value.
     */
    initializeDatabasePool(identifier?: string): void;
    /**
     * Runs is database pool initialized.
     * @param {string} [identifier] - Database identifier to check.
     * @returns {boolean} - Whether database pool initialized.
     */
    isDatabasePoolInitialized(identifier?: string): boolean;
    /**
     * Runs is initialized.
     * @returns {boolean} - Whether initialized.
     */
    isInitialized(): boolean;
    /**
     * Runs initialize models.
     * @param {object} args - Options object.
     * @param {string} args.type - Type identifier.
     * @returns {Promise<void>} - Resolves when complete.
     */
    initializeModels(args?: {
        type: string;
    }): Promise<void>;
    _modelsInitialized: boolean | undefined;
    /**
     * Ensures each configured database pool has a global connection available.
     * Useful when `getCurrentConnection` might be called without an async context.
     * @returns {Promise<void>} - Resolves when complete.
     */
    ensureGlobalConnections(): Promise<void>;
    /**
     * Runs initialize.
     * @param {object} args - Options object.
     * @param {string} args.type - Type identifier.
     * @returns {Promise<void>} - Resolves when complete.
     */
    initialize({ type }?: {
        type: string;
    }): Promise<void>;
    /**
     * Validates that resource-defined relationships are also defined on the corresponding model classes.
     * Throws an error if a relationship is defined on a resource but missing from the model.
     * @returns {void}
     */
    _validateResourceRelationshipsOnModels(): void;
    /**
     * Runs register model class.
     * @param {typeof import("./database/record/index.js").default} modelClass - Model class.
     * @returns {void} - No return value.
     */
    registerModelClass(modelClass: typeof import("./database/record/index.js").default): void;
    /**
     * Runs set current.
     * @returns {void} - No return value.
     */
    setCurrent(): void;
    /**
     * Runs get routes.
     * @returns {import("./routes/index.js").default | undefined} - The routes.
     */
    getRoutes(): import("./routes/index.js").default | undefined;
    /**
     * Runs set routes.
     * @param {import("./routes/index.js").default} newRoutes - New routes.
     * @returns {void} - No return value.
     */
    setRoutes(newRoutes: import("./routes/index.js").default): void;
    _routes: import("./routes/index.js").default | undefined;
    /**
     * Applies any `route.mount(...)` registrations from the routes file by letting
     * each mountable register its routes (typically route-resolver hooks) against
     * this configuration. Guarded so repeated setRoutes calls with the same routes
     * don't register a mount more than once.
     * @param {import("./routes/index.js").default} newRoutes - Routes instance.
     * @returns {void} - No return value.
     */
    _applyRouteMounts(newRoutes: import("./routes/index.js").default): void;
    /**
     * Adds plugin/library routes using a lightweight route DSL backed by route resolver hooks.
     * @param {(routes: import("./routes/plugin-routes.js").default) => void} callback - Routes callback.
     * @returns {void} - No return value.
     */
    routes(callback: (routes: import("./routes/plugin-routes.js").default) => void): void;
    /**
     * Runs set translator.
     * @param {function(string, Record<string, ?> | undefined) : string} callback - Translator callback.
     * @returns {void} - No return value.
     */
    setTranslator(callback: (arg0: string, arg1: Record<string, unknown> | undefined) => string): void;
    _translator: ((arg0: string, arg1: Record<string, unknown> | undefined) => string) | undefined;
    /**
     * Runs default translator.
     * @param {string} msgID - Msg id.
     * @param {Record<string, ?>} [args] - Translator options and variables.
     * @returns {string} - The default translator.
     */
    _defaultTranslator(msgID: string, args?: Record<string, unknown>): string;
    /**
     * Runs get translator.
      @returns {(msgID: string, args?: Record<string, ?>) => string} */
    getTranslator(): (msgID: string, args?: Record<string, unknown>) => string;
    _defaultTranslatorBound: ((msgID: string, args?: Record<string, unknown>) => string) | undefined;
    /**
     * Runs configure default translator.
     * @returns {void} - Configure gettext defaults for this configuration.
     */
    _configureDefaultTranslator(): void;
    /**
     * Runs get timezone offset minutes.
     * @returns {number | undefined} - The timezone offset in minutes.
     */
    getTimezoneOffsetMinutes(): number | undefined;
    /**
     * Runs get websocket events.
     * @returns {import("./http-server/websocket-events.js").default | undefined} - The websocket events.
     */
    getWebsocketEvents(): import("./http-server/websocket-events.js").default | undefined;
    /**
     * Runs set websocket events.
     * @param {import("./http-server/websocket-events.js").default} websocketEvents - Websocket events.
     * @returns {void} - No return value.
     */
    setWebsocketEvents(websocketEvents: import("./http-server/websocket-events.js").default): void;
    /**
     * Per-process registry of channel subscribers used by worker code that
     * needs to react to events broadcast via `websocketEventsHost.publish(...)`
     * without holding an actual websocket session.
     * @returns {import("./http-server/websocket-channel-subscribers.js").default} - The channel subscribers registry.
     */
    getWebsocketChannelSubscribers(): import("./http-server/websocket-channel-subscribers.js").default;
    /**
     * Runs get websocket channel resolver.
     * @returns {import("./configuration-types.js").WebsocketChannelResolverType | undefined} - The websocket channel resolver.
     */
    getWebsocketChannelResolver(): import("./configuration-types.js").WebsocketChannelResolverType | undefined;
    /**
     * Registers a `VelociousWebsocketConnection` subclass under a name.
     * Clients that send `{type: "connection-open", connectionType: name}`
     * will have this class instantiated for their connection.
     * @param {string} name
     * @param {typeof import("./http-server/websocket-connection.js").default} ConnectionClass
     * @returns {void}
     */
    registerWebsocketConnection(name: string, ConnectionClass: typeof import("./http-server/websocket-connection.js").default): void;
    /**
     * Runs get websocket connection class.
     * @param {string} name
     * @returns {typeof import("./http-server/websocket-connection.js").default | undefined}
     */
    getWebsocketConnectionClass(name: string): typeof import("./http-server/websocket-connection.js").default | undefined;
    /**
     * Registers a `VelociousWebsocketChannel` subclass under a name.
     * Clients subscribe via `{type: "channel-subscribe", channelType: name, ...}`.
     * @param {string} name
     * @param {typeof import("./http-server/websocket-channel.js").default} ChannelClass
     * @returns {void}
     */
    registerWebsocketChannel(name: string, ChannelClass: typeof import("./http-server/websocket-channel.js").default): void;
    /**
     * Runs get websocket channel class.
     * @param {string} name
     * @returns {typeof import("./http-server/websocket-channel.js").default | undefined}
     */
    getWebsocketChannelClass(name: string): typeof import("./http-server/websocket-channel.js").default | undefined;
    /**
     * Tracks a live channel subscription in the global routing registry.
     * Called by the session when `canSubscribe()` resolves truthy; the
     * session calls `_unregisterWebsocketChannelSubscription` on unsubscribe.
     * @param {string} name
     * @param {import("./http-server/websocket-channel.js").default} subscription
     * @returns {void}
     */
    _registerWebsocketChannelSubscription(name: string, subscription: import("./http-server/websocket-channel.js").default): void;
    /**
     * Runs unregister websocket channel subscription.
     * @param {string} name
     * @param {import("./http-server/websocket-channel.js").default} subscription
     * @returns {void}
     */
    _unregisterWebsocketChannelSubscription(name: string, subscription: import("./http-server/websocket-channel.js").default): void;
    /**
     * Delivers `body` to every live subscriber of `name` whose
     * `matches(broadcastParams)` returns true. Pure routing — no auth
     * re-check, no persistence. Subscribers who were admitted by
     * `canSubscribe()` continue to receive broadcasts until they
     * unsubscribe or the session ends.
     * @param {string} name
     * @param {Record<string, ?>} broadcastParams
     * @param {?} body
     * @returns {void}
     */
    /**
     * Runs get websocket session grace seconds.
     * @returns {number} - Grace period (seconds) before a paused WS session is torn down.
     */
    getWebsocketSessionGraceSeconds(): number;
    /**
     * Registers a wrapper invoked around every WS-borne request /
     * connection message / channel dispatch. The wrapper receives the
     * session and a `next` callback; it must call `next()` to run the
     * handler. Use it to set up AsyncLocalStorage per request.
     * @param {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null} wrapper
     * @returns {void}
     */
    setWebsocketAroundRequest(wrapper: ((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null): void;
    /**
     * Runs get websocket around request.
     * @returns {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null}
     */
    getWebsocketAroundRequest(): ((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null;
    /**
     * Registers a wrapper invoked around every controller action — both
     * HTTP and WS-borne. Receives `{request, response, next}` and must
     * call `next()` to run the action. Use it for per-request context
     * like AsyncLocalStorage-scoped locale or tracing.
     * @param {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null} wrapper
     * @returns {void}
     */
    setAroundAction(wrapper: ((context: {
        request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default;
        response: import("./http-server/client/response.js").default;
        next: () => Promise<void>;
    }) => Promise<void>) | null): void;
    /**
     * Runs get around action.
     * @returns {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null}
     */
    getAroundAction(): ((context: {
        request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default;
        response: import("./http-server/client/response.js").default;
        next: () => Promise<void>;
    }) => Promise<void>) | null;
    /**
     * Registers an identity resolver called once at pause time and once
     * at resume time. The resolver receives the session and returns any
     * value that identifies the authenticated caller — typically a
     * `userId` read from the session's upgrade-request cookie. Velocious
     * captures the pause-time value on the paused session and compares
     * it via `===` (or deep-equality for plain objects) to the fresh
     * resume-time value. If they differ, the resume is rejected with
     * `session-gone` and the paused session is destroyed so a signed-out
     * or re-authenticated client cannot reclaim another user's state.
     *
     * Return `null`/`undefined` to mean "no identity" — resumes still
     * succeed if pause and resume both resolve to a nullish value.
     * @param {((session: import("./http-server/client/websocket-session.js").default) => ? | Promise<?>) | null} resolver
     * @returns {void}
     */
    setWebsocketSessionIdentityResolver(resolver: ((session: import("./http-server/client/websocket-session.js").default) => unknown | Promise<unknown>) | null): void;
    /**
     * Runs get websocket session identity resolver.
      @returns {((session: import("./http-server/client/websocket-session.js").default) => ? | Promise<?>) | null} */
    getWebsocketSessionIdentityResolver(): ((session: import("./http-server/client/websocket-session.js").default) => unknown | Promise<unknown>) | null;
    /**
     * Runs set websocket session grace seconds.
     * @param {number} seconds
     * @returns {void}
     */
    setWebsocketSessionGraceSeconds(seconds: number): void;
    /**
     * Moves a session into the paused registry and starts the grace
     * timer. When the timer fires, the session's permanent teardown
     * hook is invoked. Called by the session itself from `_handleClose`
     * when there is resumable state (live Connections / Channel subs).
     * @param {import("./http-server/client/websocket-session.js").default} session
     * @returns {void}
     */
    _pauseWebsocketSession(session: import("./http-server/client/websocket-session.js").default): void;
    /**
     * Looks up a paused session by id (does NOT remove it — caller is
     * expected to call `_resumeWebsocketSession` to complete the handoff).
     * @param {string} sessionId
     * @returns {import("./http-server/client/websocket-session.js").default | null}
     */
    _findPausedWebsocketSession(sessionId: string): import("./http-server/client/websocket-session.js").default | null;
    /**
     * Removes a paused session from the registry and cancels its grace
     * timer. Called on successful resume handoff and on explicit
     * expiry.
     * @param {string} sessionId
     * @returns {void}
     */
    _clearPausedWebsocketSession(sessionId: string): void;
    /**
     * Grace-timer callback. Calls the session's permanent-teardown
     * hook and drops it from the registry.
     * @param {string} sessionId
     * @returns {void}
     */
    _expireWebsocketSession(sessionId: string): void;
    /**
     * Runs broadcast to channel.
     * @param {string} name
     * @param {Record<string, ?>} broadcastParams
     * @param {?} body
     * @returns {void}
     */
    broadcastToChannel(name: string, broadcastParams: Record<string, unknown>, body: unknown): void;
    /**
     * Awaits all pending broadcast operations (including event-log
     * persistence). Call this after `broadcastToChannel` when you need
     * the event to be persisted before continuing (e.g. before
     * responding to an HTTP request).
     * @returns {Promise<void>}
     */
    awaitPendingBroadcasts(): Promise<void>;
    /**
     * Local (per-worker) channel broadcast dispatch. Called either
     * directly (in-process mode) or by the worker thread after the
     * main-process fan-out.
     * @param {string} name - Channel name.
     * @param {Record<string, ?>} broadcastParams - Params passed to each subscription's `matches()`.
     * @param {?} body - Message body delivered via `sendMessage()`.
     * @param {{eventId?: string}} [meta] - Optional event metadata for replay tracking.
     * @returns {void}
     */
    _broadcastToChannelLocal(name: string, broadcastParams: Record<string, unknown>, body: unknown, meta?: {
        eventId?: string;
    }): void;
    /**
     * Runs deliver websocket channel broadcast.
     * @param {import("./http-server/websocket-channel.js").default} subscription - Channel subscription.
     * @param {import("./http-server/websocket-channel.js").WebsocketJsonValue} body - Broadcast body.
     * @param {{eventId?: string}} meta - Broadcast metadata.
     * @returns {void | Promise<void>} Broadcast delivery result.
     */
    _deliverWebsocketChannelBroadcast(subscription: import("./http-server/websocket-channel.js").default, body: import("./http-server/websocket-channel.js").WebsocketJsonValue, meta: {
        eventId?: string;
    }): void | Promise<void>;
    /**
     * Runs get websocket message handler resolver.
     * @returns {import("./configuration-types.js").WebsocketMessageHandlerResolverType | undefined} - The websocket message handler resolver.
     */
    getWebsocketMessageHandlerResolver(): import("./configuration-types.js").WebsocketMessageHandlerResolverType | undefined;
    /**
     * Runs set websocket channel resolver.
     * @param {import("./configuration-types.js").WebsocketChannelResolverType} resolver - Resolver.
     * @returns {void} - No return value.
     */
    setWebsocketChannelResolver(resolver: import("./configuration-types.js").WebsocketChannelResolverType): void;
    /**
     * Runs set websocket message handler resolver.
     * @param {import("./configuration-types.js").WebsocketMessageHandlerResolverType} resolver - Resolver.
     * @returns {void} - No return value.
     */
    setWebsocketMessageHandlerResolver(resolver: import("./configuration-types.js").WebsocketMessageHandlerResolverType): void;
    /**
     * Runs resolve ability.
     * @param {object} args - Ability resolver args.
     * @param {Record<string, ?>} args.params - Request params.
     * @param {import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default} args.request - Request object.
     * @param {import("./http-server/client/response.js").default} args.response - Response object.
     * @returns {Promise<import("./authorization/ability.js").default | undefined>} - Resolved ability.
     */
    resolveAbility({ params, request, response }: {
        params: Record<string, unknown>;
        request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default;
        response: import("./http-server/client/response.js").default;
    }): Promise<import("./authorization/ability.js").default | undefined>;
    /**
     * Runs run with ability.
     * @param {import("./authorization/ability.js").default | undefined} ability - Ability instance.
     * @param {() => Promise<?>} callback - Callback.
     * @returns {Promise<?>} - Callback result.
     */
    runWithAbility(ability: import("./authorization/ability.js").default | undefined, callback: () => Promise<unknown>): Promise<unknown>;
    /**
     * Runs run with request timing.
     * @param {import("./http-server/client/request-timing.js").default | undefined} requestTiming - Request timing collector.
     * @param {() => Promise<?>} callback - Callback.
     * @returns {Promise<?>} - Callback result.
     */
    runWithRequestTiming(requestTiming: import("./http-server/client/request-timing.js").default | undefined, callback: () => Promise<unknown>): Promise<unknown>;
    /**
     * Runs get current ability.
     * @returns {import("./authorization/ability.js").default | undefined} - Current ability from context.
     */
    getCurrentAbility(): import("./authorization/ability.js").default | undefined;
    /**
     * Runs get current request timing.
     * @returns {import("./http-server/client/request-timing.js").default | undefined} - Current request timing collector.
     */
    getCurrentRequestTiming(): import("./http-server/client/request-timing.js").default | undefined;
    /**
     * Runs get current tenant.
     * @returns {?} - Current tenant from context.
     */
    getCurrentTenant(): unknown;
    /**
     * Runs run with tenant.
     * @param {?} tenant - Tenant.
     * @param {() => Promise<?>} callback - Callback.
     * @returns {Promise<?>} - Callback result.
     */
    runWithTenant(tenant: unknown, callback: () => Promise<unknown>): Promise<unknown>;
    /**
     * Runs resolve tenant.
     * @param {object} args - Tenant resolver args.
     * @param {Record<string, ?>} args.params - Request params.
     * @param {import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined} args.request - Request object.
     * @param {import("./http-server/client/response.js").default | undefined} args.response - Response object.
     * @param {{channel: string, params?: Record<string, ?>}} [args.subscription] - Subscription metadata.
     * @returns {Promise<?>} - Resolved tenant.
     */
    resolveTenant({ params, request, response, subscription }: {
        params: Record<string, unknown>;
        request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined;
        response: import("./http-server/client/response.js").default | undefined;
        subscription?: {
            channel: string;
            params?: Record<string, unknown>;
        } | undefined;
    }): Promise<unknown>;
    /**
     * Runs get error events.
     * @returns {import("eventemitter3").EventEmitter} - Framework error events emitter.
     */
    getErrorEvents(): import("eventemitter3").EventEmitter;
    /**
     * Registers a reporter that can add client-safe metadata to frontend-model error payloads.
     * @param {(args: {context: ?, error: Error, request: ?}) => Promise<Record<string, ?> | void> | Record<string, ?> | void} reporter - Reporter callback.
     * @returns {void}
     */
    addClientErrorPayloadReporter(reporter: (args: {
        context: unknown;
        error: Error;
        request: unknown;
    }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void): void;
    /**
     * Runs registered client error payload reporters.
     * @param {{context: ?, error: Error, request: ?}} args - Reporter args.
     * @returns {Promise<Record<string, ?>>} - Merged client-safe reporter payload.
     */
    clientErrorPayloadForError(args: {
        context: unknown;
        error: Error;
        request: unknown;
    }): Promise<Record<string, unknown>>;
    /**
     * Runs with connections.
     * @template T
     * @param {WithConnectionsOptionsType | WithConnectionsCallbackType<T>} optionsOrCallback - Checkout options or callback function.
     * @param {WithConnectionsCallbackType<T>} [callback] - Callback function.
     * @returns {Promise<T>} - Resolves with the callback result.
     */
    withConnections<T>(optionsOrCallback: WithConnectionsOptionsType | WithConnectionsCallbackType<T>, callback?: WithConnectionsCallbackType<T>): Promise<T>;
    /**
     * Runs get current connections.
     * @returns {Record<string, import("./database/drivers/base.js").default>} A map of database connections with identifier as key
     */
    getCurrentConnections(): Record<string, import("./database/drivers/base.js").default>;
    /**
     * Runs without current connection contexts.
     * @template T
     * @param {() => T} callback - Callback to run without inherited DB connection contexts.
     * @returns {T} - Callback result.
     */
    withoutCurrentConnectionContexts<T>(callback: () => T): T;
    /**
     * Runs is missing current connection error.
     * @param {?} error - Error thrown while looking up the current connection.
     * @returns {boolean} - Whether the error means no current connection is available.
     */
    isMissingCurrentConnectionError(error: unknown): boolean;
    /**
     * Runs ensure connections.
     * @template T
     * @param {WithConnectionsOptionsType | WithConnectionsCallbackType<T>} optionsOrCallback - Checkout options or callback function.
     * @param {WithConnectionsCallbackType<T>} [callback] - Callback function.
     * @returns {Promise<T>} - Resolves with the callback result.
     */
    ensureConnections<T>(optionsOrCallback: WithConnectionsOptionsType | WithConnectionsCallbackType<T>, callback?: WithConnectionsCallbackType<T>): Promise<T>;
    /**
     * Closes active database connections and clears global connections.
     * @returns {Promise<void>} - Resolves when complete.
     */
    closeDatabaseConnections(): Promise<void>;
    /**
     * Runs debug endpoint request authorized.
     * @param {{header: (name: string) => string | null | undefined}} request - Incoming request.
     * @param {string} expectedToken - Configured debug-endpoint token.
     * @returns {boolean} - Whether the request carries the expected bearer token.
     */
    debugEndpointRequestAuthorized(request: {
        header: (name: string) => string | null | undefined;
    }, expectedToken: string): boolean;
}
/**
 * WithConnectionsCallbackType type.
 */
export type WithConnectionsCallbackType<T> = (arg0: Record<string, import("./database/drivers/base.js").default>) => Promise<T>;
/**
 * WithConnectionsOptionsType type.
 */
export type WithConnectionsOptionsType = {
    /**
     * - Human-readable name for the checked-out database connections.
     */
    name?: string | undefined;
};
import { CurrentConfigurationNotSetError } from "./current-configuration.js";
import VelociousWebsocketChannelSubscribers from "./http-server/websocket-channel-subscribers.js";
//# sourceMappingURL=configuration.d.ts.map