@technomoron/apicore-server 1.0.0-beta.1

package/dist/cjs/user/sequelize.cjs

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeUserStore = exports.AuthUserModel = void 0;
+exports.initAuthUserModel = initAuthUserModel;
+const sequelize_1 = require("sequelize");
+const user_id_js_1 = require("../auth-api/user-id.cjs");
+const sequelize_utils_js_1 = require("../sequelize-utils.cjs");
+const base_js_1 = require("./base.cjs");
+class AuthUserModel extends sequelize_1.Model {
+}
+exports.AuthUserModel = AuthUserModel;
+function initAuthUserModel(sequelize, options = {}) {
+    const idType = (0, sequelize_utils_js_1.integerIdType)(sequelize);
+    AuthUserModel.init({
+        user_id: {
+            type: idType,
+            autoIncrement: true,
+            allowNull: false,
+            primaryKey: true
+        },
+        login: {
+            type: sequelize_1.DataTypes.STRING(64),
+            allowNull: false,
+            unique: true
+        },
+        email: {
+            type: sequelize_1.DataTypes.STRING(100),
+            allowNull: false,
+            unique: true
+        },
+        password: {
+            type: sequelize_1.DataTypes.STRING(255),
+            allowNull: false
+        }
+    }, {
+        ...(0, sequelize_utils_js_1.tableOptions)(sequelize, 'users', options.tablePrefix, { timestamps: false })
+    });
+    return AuthUserModel;
+}
+class SequelizeUserStore extends base_js_1.UserStore {
+    constructor(options) {
+        super({
+            toPublic: options.toPublic,
+            bcryptRounds: options.bcryptRounds,
+            bcryptPepper: options.bcryptPepper
+        });
+        if (!options?.sequelize) {
+            throw new Error('SequelizeUserStore requires a configured Sequelize instance');
+        }
+        this.Users = options.userModel
+            ? options.userModel
+            : (options.userModelFactory ?? initAuthUserModel)(options.sequelize, {
+                tablePrefix: options.tablePrefix
+            });
+        this.recordMapper =
+            options.recordMapper ??
+                ((model) => SequelizeUserStore.mapModelToUser(model));
+    }
+    async findUser(identifier) {
+        const where = [];
+        try {
+            where.push({ user_id: this.normalizeUserId(identifier) });
+        }
+        catch {
+            // ignore
+        }
+        if (typeof identifier === 'string') {
+            where.push({ login: identifier });
+            where.push({ email: identifier });
+        }
+        if (where.length === 0) {
+            return null;
+        }
+        const model = await this.Users.findOne({ where: { [sequelize_1.Op.or]: where } });
+        return model ? this.toUserRecord(model) : null;
+    }
+    async findById(id) {
+        try {
+            const model = await this.Users.findByPk(this.normalizeUserId(id));
+            return model ? this.toUserRecord(model) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async findByLoginOrEmail(loginOrEmail) {
+        const model = await this.Users.findOne({
+            where: { [sequelize_1.Op.or]: [{ login: loginOrEmail }, { email: loginOrEmail }] }
+        });
+        return model ? this.toUserRecord(model) : null;
+    }
+    async createUser(input) {
+        const normalized = this.normalizeUserInput(input);
+        const { password, ...rest } = normalized;
+        const defaults = {
+            ...rest,
+            password: password ? await this.hashPassword(password) : ''
+        };
+        const providedId = input.user_id;
+        if (providedId !== undefined && providedId !== null && Number.isFinite(providedId)) {
+            defaults.user_id = Number(providedId);
+        }
+        try {
+            const model = await this.Users.create(defaults);
+            return this.toUserRecord(model);
+        }
+        catch (error) {
+            if (error instanceof sequelize_1.UniqueConstraintError) {
+                throw new Error(`User with login ${rest.login} or email ${rest.email} already exists`);
+            }
+            throw error;
+        }
+    }
+    async upsertUser(input) {
+        const normalized = this.normalizeUserInput(input);
+        const providedId = input.user_id;
+        if (providedId !== undefined) {
+            const model = await this.Users.findByPk(Number(providedId));
+            if (!model) {
+                throw new Error(`User ${String(providedId)} not found`);
+            }
+            const next = { ...normalized };
+            if (normalized.password && normalized.password.length > 0) {
+                next.password = await this.hashPassword(normalized.password);
+            }
+            else {
+                delete next.password;
+            }
+            await model.set(next);
+            try {
+                await model.save();
+            }
+            catch (error) {
+                if (error instanceof sequelize_1.UniqueConstraintError) {
+                    throw new Error(`User with login ${normalized.login} or email ${normalized.email} already exists`);
+                }
+                throw error;
+            }
+            return this.toUserRecord(model);
+        }
+        return this.createUser(input);
+    }
+    async updateUser(id, patch) {
+        const model = await this.Users.findByPk(this.normalizeUserId(id));
+        if (!model) {
+            throw new Error(`User ${String(id)} not found`);
+        }
+        const updates = { ...patch };
+        if (patch.password && patch.password.length > 0) {
+            updates.password = await this.hashPassword(patch.password);
+        }
+        else {
+            delete updates.password;
+        }
+        await model.set(updates);
+        try {
+            await model.save();
+        }
+        catch (error) {
+            if (error instanceof sequelize_1.UniqueConstraintError) {
+                throw new Error(`User with login or email already exists`);
+            }
+            throw error;
+        }
+        return this.toUserRecord(model);
+    }
+    async setPasswordHash(id, hash) {
+        const [affected] = await this.Users.update({ password: hash }, { where: { user_id: this.normalizeUserId(id) } });
+        if (affected === 0) {
+            throw new Error(`User ${String(id)} not found`);
+        }
+    }
+    getPasswordHash(user) {
+        return user.password;
+    }
+    getUserId(user) {
+        return user.user_id;
+    }
+    toUserRecord(model) {
+        return this.recordMapper(model);
+    }
+    static mapModelToUser(model) {
+        return {
+            user_id: model.get('user_id'),
+            login: model.get('login'),
+            email: model.get('email'),
+            password: model.get('password')
+        };
+    }
+    normalizeUserId(identifier) {
+        return (0, user_id_js_1.normalizeNumericUserId)(identifier);
+    }
+}
+exports.SequelizeUserStore = SequelizeUserStore;

package/dist/cjs/user/sequelize.d.ts

@@ -0,0 +1,46 @@
+import { CreationOptional, Model, type InferAttributes, type InferCreationAttributes, type ModelStatic, type Sequelize } from 'sequelize';
+import { UserStore } from './base.js';
+import type { CreateUserInput, PublicUserMapper, UpdateUserInput } from './types.js';
+import type { AuthIdentifier } from '../auth-api/types.js';
+export declare class AuthUserModel extends Model<InferAttributes<AuthUserModel>, InferCreationAttributes<AuthUserModel>> implements InferAttributes<AuthUserModel> {
+    user_id: CreationOptional<number>;
+    login: string;
+    email: string;
+    password: string;
+}
+export type AuthUserAttributes = InferAttributes<AuthUserModel>;
+export type AuthUserCreationAttributes = InferCreationAttributes<AuthUserModel>;
+export declare function initAuthUserModel(sequelize: Sequelize, options?: {
+    tablePrefix?: string;
+}): typeof AuthUserModel;
+export type GenericUserModel = Model<Record<string, unknown>, Record<string, unknown>>;
+export type GenericUserModelStatic = ModelStatic<GenericUserModel>;
+export interface SequelizeUserStoreOptions<UserAttributes extends AuthUserAttributes = AuthUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> {
+    bcryptRounds?: number;
+    bcryptPepper?: string;
+    sequelize: Sequelize;
+    tablePrefix?: string;
+    userModel?: GenericUserModelStatic;
+    userModelFactory?: (sequelize: Sequelize, options?: {
+        tablePrefix?: string;
+    }) => GenericUserModelStatic;
+    recordMapper?: (model: GenericUserModel) => UserAttributes;
+    toPublic?: PublicUserMapper<UserAttributes, PublicUserShape>;
+}
+export declare class SequelizeUserStore<UserAttributes extends AuthUserAttributes = AuthUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> extends UserStore<UserAttributes, PublicUserShape> {
+    readonly Users: GenericUserModelStatic;
+    private readonly recordMapper;
+    constructor(options: SequelizeUserStoreOptions<UserAttributes, PublicUserShape>);
+    findUser(identifier: AuthIdentifier | string): Promise<UserAttributes | null>;
+    findById(id: AuthIdentifier): Promise<UserAttributes | null>;
+    findByLoginOrEmail(loginOrEmail: string): Promise<UserAttributes | null>;
+    createUser(input: CreateUserInput): Promise<UserAttributes>;
+    upsertUser(input: CreateUserInput): Promise<UserAttributes>;
+    updateUser(id: AuthIdentifier, patch: UpdateUserInput): Promise<UserAttributes>;
+    setPasswordHash(id: AuthIdentifier, hash: string): Promise<void>;
+    getPasswordHash(user: UserAttributes): string | null;
+    getUserId(user: UserAttributes): AuthIdentifier;
+    protected toUserRecord(model: GenericUserModel): UserAttributes;
+    private static mapModelToUser;
+    private normalizeUserId;
+}

package/dist/cjs/user/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/user/types.d.ts

@@ -0,0 +1,11 @@
+export interface BcryptHasherOptions {
+    rounds?: number;
+    pepper?: string;
+}
+export type CreateUserInput = Record<string, unknown> & {
+    login: string;
+    email: string;
+    password?: string;
+};
+export type UpdateUserInput = Partial<CreateUserInput>;
+export type PublicUserMapper<User, PublicUser> = (user: User) => PublicUser;

package/dist/esm/api-module.d.ts

@@ -0,0 +1,45 @@
+import type { ApiRequest } from './apicore-server.js';
+export type ApiHandlerResult<Data = unknown> = [number] | [number, Data] | [number, Data, string];
+export type ApiHandler<Data = unknown> = (apiReq: ApiRequest) => Promise<ApiHandlerResult<Data>>;
+export type ApiAuthType = 'none' | 'maybe' | 'yes' | 'strict' | 'apikey';
+export type ApiAuthClass = 'any' | 'admin';
+export interface ApiKey {
+    /** Real user identity — who the key belongs to. */
+    uid: unknown;
+    /** Effective user identity — who the key acts as. When set, the request is treated as impersonation (isImpersonating() === true). */
+    euid?: unknown;
+}
+export type ApiRoute = {
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+    path: string;
+    handler: ApiHandler;
+    auth: {
+        type: ApiAuthType;
+        req: ApiAuthClass;
+    };
+    schema?: {
+        body?: Record<string, unknown>;
+        querystring?: Record<string, unknown>;
+        params?: Record<string, unknown>;
+    };
+};
+/** Base class for feature modules mounted into {@link ApiServer}. */
+export declare class ApiModule<T = unknown> {
+    private _server?;
+    /** The server instance this module is mounted on. */
+    get server(): T;
+    set server(value: T);
+    /** Route namespace under `apiBasePath`. */
+    namespace: string;
+    mountpath: string;
+    static defaultNamespace: string;
+    constructor(opts?: {
+        namespace?: string;
+    });
+    /** Optional pre-mount configuration validation hook. */
+    checkConfig(): boolean;
+    /** Return all routes exposed by this module. */
+    defineRoutes(): ApiRoute[];
+    /** Optional mount-time hook for modules that need direct server integration. */
+    onMount(): void;
+}

package/dist/esm/api-module.js

@@ -0,0 +1,30 @@
+/** Base class for feature modules mounted into {@link ApiServer}. */
+export class ApiModule {
+    /** The server instance this module is mounted on. */
+    get server() {
+        if (this._server === undefined) {
+            throw new Error('ApiModule.server is not set. Mount the module with ApiServer.api(...) before using it.');
+        }
+        return this._server;
+    }
+    set server(value) {
+        this._server = value;
+    }
+    constructor(opts = {}) {
+        this.mountpath = '';
+        this.namespace = opts.namespace ?? this.constructor.defaultNamespace ?? '';
+    }
+    /** Optional pre-mount configuration validation hook. */
+    checkConfig() {
+        return true;
+    }
+    /** Return all routes exposed by this module. */
+    defineRoutes() {
+        return [];
+    }
+    /** Optional mount-time hook for modules that need direct server integration. */
+    onMount() {
+        return;
+    }
+}
+ApiModule.defaultNamespace = '';

package/dist/esm/apicore-server.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Copyright (c) 2025 Bjørn Erik Jacobsen / Technomoron
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { type FastifyInstance, type FastifyReply, type FastifyRequest } from 'fastify';
+import { ApiModule } from './api-module.js';
+import { type ClientInfo } from './base/client-info.js';
+import { TokenStore, type JwtDecodeResult, type JwtSignPayload, type JwtSignResult, type JwtVerifyResult } from './token/base.js';
+import type { ApiAuthClass, ApiAuthType, ApiHandler, ApiKey } from './api-module.js';
+import type { AuthProviderModule } from './auth-api/module.js';
+import type { AuthAdapter, AuthIdentifier } from './auth-api/types.js';
+import type { AuthCodeData, AuthCodeRequest, OAuthClient } from './oauth/types.js';
+import type { PasskeyChallenge, PasskeyChallengeParams, StoredPasskeyCredential, PasskeyVerificationParams, PasskeyVerificationResult } from './passkey/types.js';
+import type { Token } from './token/types.js';
+import type { JwtPayload, SignOptions, VerifyOptions } from 'jsonwebtoken';
+export type { JwtPayload, SignOptions, VerifyOptions } from 'jsonwebtoken';
+export type { ClientAgentProfile, ClientInfo } from './base/client-info.js';
+export interface ApiCookieOptions {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+    domain?: string;
+    path?: string;
+    maxAge?: number;
+    expires?: Date;
+}
+export interface ApiUploadedFile {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size?: number;
+    buffer?: Buffer;
+    filepath?: string;
+}
+export interface ExtendedReq {
+    method: string;
+    url: string;
+    originalUrl?: string;
+    headers: Record<string, string | string[] | undefined>;
+    query: Record<string, unknown>;
+    body: unknown;
+    params: Record<string, unknown>;
+    cookies?: Record<string, string>;
+    ip?: string;
+    ips?: string[];
+    socket?: {
+        remoteAddress?: string;
+    };
+    protocol?: string;
+    file?: ApiUploadedFile;
+    files?: ApiUploadedFile[] | Record<string, ApiUploadedFile[]>;
+    apiReq?: ApiRequest;
+}
+export interface ApiResponse {
+    locals: Record<string, unknown>;
+    headersSent: boolean;
+    status: (code: number) => ApiResponse;
+    json: (payload: unknown) => void;
+    send: (payload: unknown) => void;
+    cookie: (name: string, value: string, options?: ApiCookieOptions) => void;
+    clearCookie: (name: string, options?: ApiCookieOptions) => void;
+}
+export interface ApiTokenData extends JwtPayload, Partial<Token> {
+    uid: unknown;
+    iat?: number;
+    exp?: number;
+}
+export type ApiAuthMethod = 'bearer' | 'cookie' | 'param' | 'apikey' | null;
+export interface ApiRequest {
+    server: ApiServer;
+    req: ExtendedReq;
+    res: ApiResponse;
+    tokenData?: ApiTokenData | null;
+    token?: string;
+    authToken?: Token | null;
+    apiKey?: ApiKey | null;
+    authMethod?: ApiAuthMethod;
+    clientInfo?: ClientInfo;
+    realUid?: AuthIdentifier | null;
+    getClientInfo: () => ClientInfo;
+    getClientIp: () => string | null;
+    getClientIpChain: () => string[];
+    getRealUid: () => AuthIdentifier | null;
+    isImpersonating: () => boolean;
+}
+export type ExpressApiRequest = ExtendedReq;
+export interface ExpressApiLocals {
+    apiReq?: ApiRequest;
+}
+type CompatNext = (error?: unknown) => void;
+type CompatRequestHandler = (req: ExtendedReq, res: ApiResponse, next: CompatNext) => unknown;
+type CompatErrorHandler = (err: unknown, req: ExtendedReq, res: ApiResponse, next: CompatNext) => unknown;
+export { ApiModule } from './api-module.js';
+export type { ApiHandler, ApiAuthType, ApiAuthClass, ApiRoute, ApiKey } from './api-module.js';
+export interface ApiErrorParams {
+    code?: number;
+    message?: unknown;
+    data?: unknown;
+    errors?: Record<string, string>;
+}
+export declare class ApiError extends Error {
+    code: number;
+    data: unknown;
+    errors: Record<string, string>;
+    constructor({ code, message, data, errors }: ApiErrorParams);
+}
+export interface ApiServerConf {
+    apiPort: number;
+    apiHost: string;
+    uploadPath: string;
+    uploadMax: number;
+    staticDirs?: Record<string, string>;
+    origins: string[];
+    debug: boolean;
+    apiBasePath: string;
+    swaggerEnabled?: boolean;
+    swaggerPath?: string;
+    accessSecret: string;
+    refreshSecret: string;
+    cookieDomain: string;
+    cookiePath?: string;
+    cookieSameSite?: 'lax' | 'strict' | 'none';
+    cookieSecure?: boolean | 'auto';
+    cookieHttpOnly?: boolean;
+    apiKeyPrefix: string;
+    apiKeyEnabled: boolean;
+    tokenParam: string;
+    tokenParamLocation: 'body' | 'query' | 'body-query';
+    accessCookie: string;
+    refreshCookie: string;
+    accessExpiry: number;
+    refreshExpiry: number;
+    sessionRefreshExpiry: number;
+    authApi: boolean;
+    devMode: boolean;
+    hydrateGetBody: boolean;
+    validateTokens: boolean;
+    refreshMaybe: boolean;
+    apiVersion: string;
+    minClientVersion: string;
+    tokenStore?: TokenStore;
+    onStartError?: (error: Error) => void;
+    /**
+     * Controls trust in proxy headers (X-Forwarded-For, Forwarded, X-Real-IP).
+     * - `true` (default): trust all forwarded headers
+     * - `false`: only use the socket address, ignore forwarded headers
+     * - number: trust that many rightmost forwarded entries (e.g., 1 = one reverse proxy)
+     */
+    trustProxy: boolean | number;
+}
+/** Core Fastify-based API server with module mounting and auth integration hooks. */
+export declare class ApiServer {
+    readonly app: ((req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => void) & {
+        listen: (...args: unknown[]) => import('node:http').Server;
+    };
+    readonly fastify: FastifyInstance;
+    readonly config: ApiServerConf;
+    readonly startedAt: number;
+    private readonly apiBasePath;
+    private finalized;
+    private storageAdapter;
+    private moduleAdapter;
+    private apiErrorHandlerInstalled;
+    private tokenStoreAdapter;
+    private readonly jwtHelper;
+    private compatGlobalErrorHandler;
+    private readonly readyPromise;
+    private currReqDeprecationWarned;
+    get currReq(): ApiRequest | null;
+    set currReq(_value: ApiRequest | null);
+    constructor(config?: Partial<ApiServerConf>);
+    private setupRuntime;
+    private readRawBody;
+    private parseRawBody;
+    private assertNotFinalized;
+    finalize(): this;
+    authStorage<UserRow, SafeUser>(storage: AuthAdapter<UserRow, SafeUser>): this;
+    useAuthStorage<UserRow, SafeUser>(storage: AuthAdapter<UserRow, SafeUser>): this;
+    authModule<UserRow>(module: AuthProviderModule<UserRow>): this;
+    useAuthModule<UserRow>(module: AuthProviderModule<UserRow>): this;
+    getAuthStorage<UserRow = unknown, SafeUser = unknown>(): AuthAdapter<UserRow, SafeUser>;
+    getAuthModule<UserRow = unknown>(): AuthProviderModule<UserRow>;
+    setTokenStore(store: TokenStore): this;
+    getTokenStore(): TokenStore | null;
+    listUserCredentials(userId: AuthIdentifier): Promise<StoredPasskeyCredential[]>;
+    deletePasskeyCredential(credentialId: Buffer | string): Promise<boolean>;
+    getUser(identifier: AuthIdentifier): Promise<unknown | null>;
+    getUserPasswordHash(user: unknown): string;
+    getUserId(user: unknown): AuthIdentifier;
+    filterUser(user: unknown): unknown;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+    storeToken(data: Token): Promise<void>;
+    getToken(query: Partial<Token> & {
+        userId?: AuthIdentifier;
+        ruid?: AuthIdentifier;
+    }, opts?: {
+        includeExpired?: boolean;
+    }): Promise<Token | null>;
+    deleteToken(query: Partial<Token> & {
+        userId?: AuthIdentifier;
+        ruid?: AuthIdentifier;
+    }): Promise<number>;
+    createPasskeyChallenge(params: PasskeyChallengeParams): Promise<PasskeyChallenge>;
+    verifyPasskeyResponse(params: PasskeyVerificationParams): Promise<PasskeyVerificationResult>;
+    getClient(clientId: string): Promise<OAuthClient | null>;
+    verifyClientSecret(client: OAuthClient, clientSecret: string | null): Promise<boolean>;
+    createAuthCode(request: AuthCodeRequest): Promise<AuthCodeData>;
+    consumeAuthCode(code: string, clientId: string): Promise<AuthCodeData | null>;
+    canImpersonate(params: {
+        realUserId: AuthIdentifier;
+        effectiveUserId: AuthIdentifier;
+    }): Promise<boolean>;
+    jwtSign(payload: JwtSignPayload, secret: string, expiresInSeconds: number, options?: SignOptions): JwtSignResult;
+    jwtVerify<T>(token: string, secret: string, options?: VerifyOptions): JwtVerifyResult<T>;
+    jwtDecode<T>(token: string, options?: import('jsonwebtoken').DecodeOptions): JwtDecodeResult<T>;
+    getApiKey<T = ApiKey>(token: string): Promise<T | null>;
+    authenticateUser(params: {
+        login: string;
+        password: string;
+    }): Promise<boolean>;
+    updateToken(updates: Partial<Token> & {
+        refreshToken: string;
+    }): Promise<boolean>;
+    guessExceptionText(error: unknown, defMsg?: string): string;
+    protected authorize(apiReq: ApiRequest, requiredClass: ApiAuthClass): Promise<void>;
+    /**
+     * Authenticate and authorise an incoming Fastify request outside of the
+     * standard `defineRoutes` pipeline (e.g. TUS upload routes that need full
+     * control over their own response format).
+     *
+     * Throws `ApiError` on auth failure — callers should catch it and respond
+     * with the appropriate HTTP status code.
+     */
+    resolveRequest(request: FastifyRequest, reply: FastifyReply, auth: {
+        type: ApiAuthType;
+        req?: ApiAuthClass;
+    }): Promise<ApiRequest>;
+    private installStaticDirs;
+    private installPingHandler;
+    private loadSwaggerSpec;
+    private readPackageVersion;
+    private installSwaggerHandler;
+    private normalizeApiBasePath;
+    private installApiNotFoundHandler;
+    private installApiErrorHandler;
+    start(): this;
+    private internalServerErrorMessage;
+    private logUnhandledError;
+    private verifyJWT;
+    private jwtCookieOptions;
+    private setAccessCookie;
+    private tryRefreshAccessToken;
+    private authenticate;
+    private tryAuthenticateApiKey;
+    private resolveTokenFromRequest;
+    private readNamedValue;
+    private requiresAuthToken;
+    private shouldValidateStoredToken;
+    private assertStoredAccessToken;
+    private normalizeAuthIdentifier;
+    private extractTokenUserId;
+    private resolveRealUserId;
+    private toExtendedReq;
+    private createApiRequest;
+    useExpress(path: string, ...handlers: Array<CompatRequestHandler | CompatErrorHandler>): this;
+    useExpress(...handlers: Array<CompatRequestHandler | CompatErrorHandler>): this;
+    private runCompatHandlers;
+    private runCompatErrorHandlers;
+    expressAuth(auth: {
+        type: ApiAuthType;
+        req: ApiAuthClass;
+    }): CompatRequestHandler;
+    expressErrorHandler(): CompatErrorHandler;
+    private handleRequest;
+    protected handle_request(handler: ApiHandler, auth: {
+        type: ApiAuthType;
+        req: ApiAuthClass;
+    }): (req: ExtendedReq, res: ApiResponse, next: (error?: unknown) => void) => Promise<void>;
+    api<T extends ApiModule<unknown>>(module: T): this;
+    private joinRoutePath;
+    dumpRequest(apiReq: ApiRequest): void;
+    private formatDebugValue;
+    dumpResponse(apiReq: ApiRequest, payload: unknown, status: number): void;
+}
+export default ApiServer;