@technomoron/apicore-server 1.0.0-beta.1

package/dist/esm/auth-api/sql-auth-store.d.ts

@@ -0,0 +1,87 @@
+import { Sequelize, type SyncOptions } from 'sequelize';
+import { SequelizeOAuthStore, type SequelizeOAuthStoreOptions } from '../oauth/sequelize.js';
+import { SequelizePasskeyStore } from '../passkey/sequelize.js';
+import { type SequelizeTokenStoreOptions } from '../token/sequelize.js';
+import { SequelizeUserStore, type AuthUserAttributes, GenericUserModel, GenericUserModelStatic } from '../user/sequelize.js';
+import type { AuthAdapter, AuthIdentifier } from './types.js';
+import type { AuthCodeData, AuthCodeRequest, OAuthClient } from '../oauth/types.js';
+import type { PasskeyChallenge, PasskeyChallengeParams, PasskeyServiceConfig, PasskeyUserDescriptor, StoredPasskeyCredential, PasskeyVerificationParams, PasskeyVerificationResult } from '../passkey/types.js';
+import type { TokenStore } from '../token/base.js';
+import type { Token } from '../token/types.js';
+interface PasskeyOptions extends Partial<PasskeyServiceConfig> {
+    enabled?: boolean;
+}
+export interface SqlAuthStoreTablePrefixes {
+    user?: string;
+    token?: string;
+    passkey?: string;
+    oauth?: string;
+}
+export interface SqlAuthStoreParams<UserAttributes extends AuthUserAttributes = AuthUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> {
+    sequelize: Sequelize;
+    syncOptions?: SyncOptions;
+    bcryptRounds?: number;
+    passwordPepper?: string;
+    tablePrefix?: string;
+    tablePrefixes?: SqlAuthStoreTablePrefixes;
+    userModel?: GenericUserModelStatic;
+    userModelFactory?: (sequelize: Sequelize, options?: {
+        tablePrefix?: string;
+    }) => GenericUserModelStatic;
+    userRecordMapper?: (model: GenericUserModel) => UserAttributes;
+    publicUserMapper?: (user: UserAttributes) => PublicUserShape;
+    passkeyUserMapper?: (user: UserAttributes) => PasskeyUserDescriptor;
+    passkeys?: false | PasskeyOptions;
+    canImpersonate?: (params: {
+        realUserId: AuthIdentifier;
+        effectiveUserId: AuthIdentifier;
+    }) => boolean | Promise<boolean>;
+    tokenStore?: TokenStore;
+    tokenStoreOptions?: Omit<SequelizeTokenStoreOptions, 'sequelize'>;
+    oauthStoreOptions?: Omit<SequelizeOAuthStoreOptions, 'sequelize'>;
+}
+export declare class SqlAuthStore<UserAttributes extends AuthUserAttributes = AuthUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> implements AuthAdapter<UserAttributes, PublicUserShape> {
+    readonly userStore: SequelizeUserStore<UserAttributes, PublicUserShape>;
+    readonly tokenStore: TokenStore;
+    readonly passkeyStore?: SequelizePasskeyStore;
+    readonly oauthStore: SequelizeOAuthStore;
+    private readonly adapter;
+    private readonly sequelize;
+    private closed;
+    private readonly syncOptions?;
+    constructor(params: SqlAuthStoreParams<UserAttributes, PublicUserShape>);
+    initialise(withSync?: boolean): Promise<void>;
+    close(): Promise<void>;
+    getUser(identifier: AuthIdentifier): Promise<UserAttributes | null>;
+    getUserPasswordHash(user: UserAttributes): string;
+    getUserId(user: UserAttributes): AuthIdentifier;
+    filterUser(user: UserAttributes): PublicUserShape;
+    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>;
+    updateToken(updates: Partial<Token> & {
+        refreshToken: string;
+    }): Promise<boolean>;
+    createPasskeyChallenge(params: PasskeyChallengeParams): Promise<PasskeyChallenge>;
+    verifyPasskeyResponse(params: PasskeyVerificationParams): Promise<PasskeyVerificationResult>;
+    listUserCredentials(userId: AuthIdentifier): Promise<StoredPasskeyCredential[]>;
+    deletePasskeyCredential(credentialId: Buffer | string): Promise<boolean>;
+    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>;
+}
+export {};

package/dist/esm/auth-api/sql-auth-store.js

@@ -0,0 +1,175 @@
+import { SequelizeOAuthStore } from '../oauth/sequelize.js';
+import { normalizePasskeyConfig } from '../passkey/config.js';
+import { SequelizePasskeyStore } from '../passkey/sequelize.js';
+import { normalizeTablePrefix } from '../sequelize-utils.js';
+import { SequelizeTokenStore } from '../token/sequelize.js';
+import { SequelizeUserStore } from '../user/sequelize.js';
+import { CompositeAuthAdapter } from './compat-auth-storage.js';
+import { toOptionalStringId } from './user-id.js';
+function resolveTablePrefix(...prefixes) {
+    for (const prefix of prefixes) {
+        const normalized = normalizeTablePrefix(prefix);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+export class SqlAuthStore {
+    constructor(params) {
+        this.closed = false;
+        if (!params?.sequelize) {
+            throw new Error('SqlAuthStore requires an initialised Sequelize instance');
+        }
+        this.sequelize = params.sequelize;
+        this.syncOptions = params.syncOptions;
+        const moduleTablePrefixes = params.tablePrefixes ?? {};
+        const userTablePrefix = resolveTablePrefix(moduleTablePrefixes.user, params.tablePrefix);
+        this.userStore = new SequelizeUserStore({
+            sequelize: this.sequelize,
+            userModel: params.userModel,
+            userModelFactory: params.userModelFactory,
+            recordMapper: params.userRecordMapper,
+            toPublic: params.publicUserMapper,
+            bcryptRounds: params.bcryptRounds,
+            bcryptPepper: params.passwordPepper,
+            tablePrefix: userTablePrefix
+        });
+        const tokenTablePrefix = resolveTablePrefix(params.tokenStoreOptions?.tablePrefix, moduleTablePrefixes.token, params.tablePrefix);
+        this.tokenStore =
+            params.tokenStore ??
+                new SequelizeTokenStore({
+                    sequelize: this.sequelize,
+                    ...params.tokenStoreOptions,
+                    tablePrefix: tokenTablePrefix
+                });
+        const oauthTablePrefix = resolveTablePrefix(params.oauthStoreOptions?.tablePrefix, moduleTablePrefixes.oauth, params.tablePrefix);
+        this.oauthStore = new SequelizeOAuthStore({
+            sequelize: this.sequelize,
+            ...params.oauthStoreOptions,
+            tablePrefix: oauthTablePrefix,
+            bcryptRounds: params.bcryptRounds
+        });
+        let passkeyStore;
+        let passkeyConfig;
+        if (params.passkeys !== false) {
+            const passkeyTablePrefix = resolveTablePrefix(moduleTablePrefixes.passkey, params.tablePrefix);
+            passkeyConfig = normalizePasskeyConfig(params.passkeys ?? {});
+            const resolveUser = async (lookup) => {
+                const found = await this.userStore.findUser(lookup.userId ?? lookup.login ?? '');
+                if (!found) {
+                    return null;
+                }
+                const mapper = params.passkeyUserMapper ??
+                    ((user) => ({
+                        id: (this.userStore.getUserId(user) ?? user['user_id']),
+                        login: user.login ?? String(this.userStore.getUserId(user)),
+                        displayName: user.login ?? String(this.userStore.getUserId(user))
+                    }));
+                return mapper(found);
+            };
+            passkeyStore = new SequelizePasskeyStore({
+                sequelize: this.sequelize,
+                resolveUser,
+                tablePrefix: passkeyTablePrefix
+            });
+            this.passkeyStore = passkeyStore;
+        }
+        this.adapter = new CompositeAuthAdapter({
+            userStore: this.userStore,
+            tokenStore: this.tokenStore,
+            passkeys: passkeyStore && passkeyConfig ? { store: passkeyStore, config: passkeyConfig } : undefined,
+            oauthStore: this.oauthStore,
+            canImpersonate: params.canImpersonate
+        });
+    }
+    async initialise(withSync = false) {
+        await this.sequelize.authenticate();
+        if (withSync) {
+            await this.sequelize.sync(this.syncOptions);
+        }
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            await this.sequelize.close();
+        }
+        catch (error) {
+            const message = error?.message ?? '';
+            if (!/closed/i.test(message)) {
+                throw error;
+            }
+        }
+        finally {
+            // Prevent double-close errors when the same Sequelize instance is shared with other code.
+            this.sequelize.close = async () => { };
+        }
+    }
+    async getUser(identifier) {
+        return this.adapter.getUser(identifier);
+    }
+    getUserPasswordHash(user) {
+        return this.adapter.getUserPasswordHash(user);
+    }
+    getUserId(user) {
+        return this.adapter.getUserId(user);
+    }
+    filterUser(user) {
+        return this.adapter.filterUser(user);
+    }
+    async verifyPassword(password, hash) {
+        return this.adapter.verifyPassword(password, hash);
+    }
+    async storeToken(data) {
+        return this.adapter.storeToken(data);
+    }
+    async getToken(query, opts) {
+        const normalized = {
+            ...query,
+            userId: toOptionalStringId(query.userId),
+            ruid: toOptionalStringId(query.ruid)
+        };
+        return this.adapter.getToken(normalized, opts);
+    }
+    async deleteToken(query) {
+        const normalized = {
+            ...query,
+            userId: toOptionalStringId(query.userId),
+            ruid: toOptionalStringId(query.ruid)
+        };
+        return this.adapter.deleteToken(normalized);
+    }
+    async updateToken(updates) {
+        return this.adapter.updateToken(updates);
+    }
+    async createPasskeyChallenge(params) {
+        return this.adapter.createPasskeyChallenge(params);
+    }
+    async verifyPasskeyResponse(params) {
+        return this.adapter.verifyPasskeyResponse(params);
+    }
+    async listUserCredentials(userId) {
+        return this.adapter.listUserCredentials(userId);
+    }
+    async deletePasskeyCredential(credentialId) {
+        return this.adapter.deletePasskeyCredential(credentialId);
+    }
+    async getClient(clientId) {
+        return this.adapter.getClient(clientId);
+    }
+    async verifyClientSecret(client, clientSecret) {
+        return this.adapter.verifyClientSecret(client, clientSecret);
+    }
+    async createAuthCode(request) {
+        return this.adapter.createAuthCode(request);
+    }
+    async consumeAuthCode(code, clientId) {
+        return this.adapter.consumeAuthCode(code, clientId);
+    }
+    async canImpersonate(params) {
+        return this.adapter.canImpersonate(params);
+    }
+}

package/dist/esm/auth-api/storage.d.ts

@@ -0,0 +1,38 @@
+import type { AuthAdapter, AuthIdentifier } from './types.js';
+import type { AuthCodeData, AuthCodeRequest, OAuthClient } from '../oauth/types.js';
+import type { PasskeyChallenge, PasskeyChallengeParams, PasskeyVerificationParams, PasskeyVerificationResult, StoredPasskeyCredential } from '../passkey/types.js';
+import type { Token } from '../token/types.js';
+export declare class BaseAuthAdapter<UserRow = unknown, SafeUser = unknown> implements AuthAdapter<UserRow, SafeUser> {
+    getUser(identifier: AuthIdentifier): Promise<UserRow | null>;
+    getUserPasswordHash(user: UserRow): string;
+    getUserId(user: UserRow): AuthIdentifier;
+    filterUser(user: UserRow): SafeUser;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+    storeToken(data: Token): Promise<void>;
+    getToken(query: Partial<Omit<Token, 'userId' | 'ruid'>> & {
+        userId?: string | number;
+        ruid?: string | number;
+    }, opts?: {
+        includeExpired?: boolean;
+    }): Promise<Token | null>;
+    deleteToken(query: Partial<Omit<Token, 'userId' | 'ruid'>> & {
+        userId?: string | number;
+        ruid?: string | number;
+    }): Promise<number>;
+    updateToken(updates: Partial<Token> & {
+        refreshToken: string;
+    }): Promise<boolean>;
+    createPasskeyChallenge(params: PasskeyChallengeParams): Promise<PasskeyChallenge>;
+    verifyPasskeyResponse(params: PasskeyVerificationParams): Promise<PasskeyVerificationResult>;
+    listUserCredentials(userId: AuthIdentifier): Promise<StoredPasskeyCredential[]>;
+    deletePasskeyCredential(credentialId: Buffer | string): Promise<boolean>;
+    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>;
+}
+export declare const nullAuthAdapter: AuthAdapter<unknown, unknown>;

package/dist/esm/auth-api/storage.js

@@ -0,0 +1,98 @@
+// Handy base you can extend when wiring a real auth adapter. Every method
+// throws by default so unimplemented hooks fail loudly.
+export class BaseAuthAdapter {
+    // Override to load a user record by identifier
+    async getUser(identifier) {
+        void identifier;
+        return null;
+    }
+    // Override to return the stored password hash for the user
+    getUserPasswordHash(user) {
+        void user;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to expose the canonical user identifier
+    getUserId(user) {
+        void user;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to strip sensitive fields from the user record
+    filterUser(user) {
+        return user;
+    }
+    // Override to validate a raw password against the stored hash
+    async verifyPassword(password, hash) {
+        void password;
+        void hash;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to persist newly issued tokens
+    async storeToken(data) {
+        void data;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to look up a stored token by query
+    async getToken(query, opts) {
+        void query;
+        void opts;
+        return null;
+    }
+    // Override to remove stored tokens that match the query
+    async deleteToken(query) {
+        void query;
+        return 0;
+    }
+    // Override to update metadata for an existing refresh token
+    async updateToken(updates) {
+        void updates;
+        return false;
+    }
+    // Override to create a new passkey challenge record
+    async createPasskeyChallenge(params) {
+        void params;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to verify an incoming WebAuthn response
+    async verifyPasskeyResponse(params) {
+        void params;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to list passkey credentials for a user
+    async listUserCredentials(userId) {
+        void userId;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to delete a passkey credential
+    async deletePasskeyCredential(credentialId) {
+        void credentialId;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to fetch an OAuth client by identifier
+    async getClient(clientId) {
+        void clientId;
+        return null;
+    }
+    // Override to compare a provided client secret against storage
+    async verifyClientSecret(client, clientSecret) {
+        void client;
+        void clientSecret;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to create a new authorization code entry
+    async createAuthCode(request) {
+        void request;
+        throw new Error('Auth storage not configured');
+    }
+    // Override to consume and invalidate an authorization code
+    async consumeAuthCode(code, clientId) {
+        void code;
+        void clientId;
+        return null;
+    }
+    // Override to decide if a real user may impersonate another user
+    async canImpersonate(params) {
+        void params;
+        return false;
+    }
+}
+export const nullAuthAdapter = new BaseAuthAdapter();

package/dist/esm/auth-api/types.d.ts

@@ -0,0 +1,34 @@
+import type { AuthCodeData, AuthCodeRequest, OAuthClient } from '../oauth/types.js';
+import type { PasskeyChallenge, PasskeyChallengeParams, PasskeyVerificationParams, PasskeyVerificationResult, StoredPasskeyCredential } from '../passkey/types.js';
+import type { Token } from '../token/types.js';
+export type AuthIdentifier = string | number;
+/** @internal */
+export interface AuthAdapter<UserRow, SafeUser> {
+    getUser(identifier: AuthIdentifier): Promise<UserRow | null>;
+    getUserPasswordHash(user: UserRow): string;
+    getUserId(user: UserRow): AuthIdentifier;
+    filterUser(user: UserRow): SafeUser;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+    storeToken(data: Token): Promise<void>;
+    getToken(query: Partial<Token>, opts?: {
+        includeExpired?: boolean;
+    }): Promise<Token | null>;
+    deleteToken(query: Partial<Token>): Promise<number>;
+    updateToken?(updates: Partial<Token> & {
+        refreshToken: string;
+    }): Promise<boolean>;
+    createPasskeyChallenge?(params: PasskeyChallengeParams): Promise<PasskeyChallenge>;
+    verifyPasskeyResponse?(params: PasskeyVerificationParams): Promise<PasskeyVerificationResult>;
+    listUserCredentials?(userId: AuthIdentifier): Promise<StoredPasskeyCredential[]>;
+    deletePasskeyCredential?(credentialId: Buffer | string): Promise<boolean>;
+    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>;
+}
+/** @internal */
+export type AuthStorage<UserRow, SafeUser> = AuthAdapter<UserRow, SafeUser>;

package/dist/esm/auth-api/types.js

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

package/dist/esm/auth-api/user-id.d.ts

@@ -0,0 +1,5 @@
+import type { AuthIdentifier } from './types.js';
+export declare function normalizeComparableUserId(identifier: AuthIdentifier): string;
+export declare function normalizeNumericUserId(identifier: AuthIdentifier): number;
+export declare function normalizeStringUserId(identifier: AuthIdentifier): string;
+export declare function toOptionalStringId(value: AuthIdentifier | undefined | null): string | undefined;

package/dist/esm/auth-api/user-id.js

@@ -0,0 +1,41 @@
+export function normalizeComparableUserId(identifier) {
+    if (typeof identifier === 'number' && Number.isFinite(identifier)) {
+        return String(identifier);
+    }
+    if (typeof identifier === 'string') {
+        const trimmed = identifier.trim();
+        if (trimmed.length === 0) {
+            throw new Error(`Unable to normalise user identifier: ${identifier}`);
+        }
+        if (/^\d+$/.test(trimmed)) {
+            const num = Number(trimmed);
+            // Avoid precision loss for large numeric strings
+            if (!Number.isSafeInteger(num)) {
+                return trimmed;
+            }
+            return String(num);
+        }
+        return trimmed;
+    }
+    throw new Error(`Unable to normalise user identifier: ${identifier}`);
+}
+export function normalizeNumericUserId(identifier) {
+    const normalized = normalizeComparableUserId(identifier);
+    if (/^\d+$/.test(normalized)) {
+        const num = Number(normalized);
+        if (!Number.isSafeInteger(num)) {
+            throw new Error(`Sequelize OAuth/Passkey store requires numeric user IDs within safe integer range: ${identifier}`);
+        }
+        return num;
+    }
+    throw new Error(`Sequelize OAuth/Passkey store requires numeric user IDs: ${identifier}`);
+}
+export function normalizeStringUserId(identifier) {
+    return normalizeComparableUserId(identifier);
+}
+export function toOptionalStringId(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    return String(value);
+}

package/dist/esm/auth-cookie-options.d.ts

@@ -0,0 +1,13 @@
+import type { ApiCookieOptions } from './apicore-server.js';
+export interface AuthCookieConfig {
+    cookieSecure?: boolean | 'auto';
+    cookieSameSite?: 'lax' | 'strict' | 'none';
+    cookieHttpOnly?: boolean;
+    cookieDomain?: string;
+    cookiePath?: string;
+    devMode?: boolean;
+}
+export declare function buildAuthCookieOptions(config: AuthCookieConfig, req: {
+    headers: Record<string, string | string[] | undefined>;
+    protocol?: string;
+}): ApiCookieOptions;

package/dist/esm/auth-cookie-options.js

@@ -0,0 +1,63 @@
+function firstHeaderValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value[0] ?? '';
+    }
+    return '';
+}
+function resolveOriginHostname(origin) {
+    try {
+        const url = new URL(origin);
+        const hostname = url.hostname.trim().toLowerCase();
+        return hostname.length > 0 ? hostname : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isLocalhostOrigin(origin) {
+    const hostname = resolveOriginHostname(origin);
+    if (!hostname) {
+        return false;
+    }
+    return hostname === 'localhost' || hostname.endsWith('.localhost');
+}
+export function buildAuthCookieOptions(config, req) {
+    const forwardedProto = firstHeaderValue(req.headers['x-forwarded-proto']).split(',')[0].trim().toLowerCase();
+    const isHttps = forwardedProto === 'https' || req.protocol === 'https';
+    const origin = firstHeaderValue(req.headers.origin ?? req.headers.referer);
+    let secure;
+    if (config.cookieSecure === true) {
+        secure = true;
+    }
+    else if (config.cookieSecure === false) {
+        secure = false;
+    }
+    else {
+        secure = isHttps;
+    }
+    let sameSite = config.cookieSameSite ?? 'lax';
+    if (sameSite !== 'lax' && sameSite !== 'strict' && sameSite !== 'none') {
+        sameSite = 'lax';
+    }
+    let resolvedSecure = secure;
+    if (sameSite === 'none' && resolvedSecure !== true) {
+        // Modern browsers reject SameSite=None cookies unless Secure is set.
+        resolvedSecure = true;
+    }
+    const options = {
+        httpOnly: config.cookieHttpOnly ?? true,
+        secure: resolvedSecure,
+        sameSite,
+        domain: config.cookieDomain || undefined,
+        path: config.cookiePath || '/',
+        maxAge: undefined
+    };
+    if (config.devMode && isLocalhostOrigin(origin)) {
+        // Domain cookies do not work on localhost; avoid breaking local development when cookieDomain is set.
+        options.domain = undefined;
+    }
+    return options;
+}

package/dist/esm/base/client-info.d.ts

@@ -0,0 +1,27 @@
+interface ClientInfoRequest {
+    headers: Record<string, string | string[] | undefined>;
+    ips?: string[];
+    ip?: string;
+    socket?: {
+        remoteAddress?: string;
+    };
+    connection?: {
+        remoteAddress?: string;
+    };
+}
+export interface ClientAgentProfile {
+    ua: string;
+    browser: string;
+    os: string;
+    device: string;
+}
+export interface ClientInfo extends ClientAgentProfile {
+    ip: string | null;
+    ipchain: string[];
+}
+interface ApiRequestWithClientInfo {
+    req: ClientInfoRequest;
+    clientInfo?: ClientInfo;
+}
+export declare function ensureClientInfo(apiReq: ApiRequestWithClientInfo, trustProxy?: boolean | number): ClientInfo;
+export {};