@unchainedshop/core-users 4.3.5 → 4.5.0

package/README.md

@@ -1,3 +1,125 @@
-# Users (Unchained Engine)
+[![npm version](https://img.shields.io/npm/v/@unchainedshop/core-users.svg)](https://npmjs.com/package/@unchainedshop/core-users)
+[![License: EUPL-1.2](https://img.shields.io/badge/License-EUPL--1.2-blue.svg)](https://opensource.org/licenses/EUPL-1.2)
 
-This package contains business logic and database abstraction for users in Unchained.
+# @unchainedshop/core-users
+
+User management module for the Unchained Engine. Handles user accounts, authentication, profiles, and WebAuthn support.
+
+## Installation
+
+```bash
+npm install @unchainedshop/core-users
+```
+
+## Usage
+
+```typescript
+import { configureUsersModule } from '@unchainedshop/core-users';
+
+const usersModule = await configureUsersModule({ db });
+
+// Find users
+const users = await usersModule.findUsers({
+  includeGuests: false,
+  limit: 50,
+});
+
+// Create a user
+const userId = await usersModule.createUser({
+  email: 'user@example.com',
+  password: 'securePassword',
+});
+
+// Update profile
+await usersModule.updateProfile(userId, {
+  displayName: 'John Doe',
+});
+```
+
+## API Overview
+
+### Module Configuration
+
+| Export | Description |
+|--------|-------------|
+| `configureUsersModule` | Configure and return the users module |
+| `configureUsersWebAuthnModule` | Configure WebAuthn submodule |
+
+### Queries
+
+| Method | Description |
+|--------|-------------|
+| `findUser` | Find user by ID, email, or username |
+| `findUsers` | Find users with filtering, sorting, and pagination |
+| `count` | Count users matching query |
+| `userExists` | Check if a user exists |
+
+### Mutations
+
+| Method | Description |
+|--------|-------------|
+| `createUser` | Create a new user account |
+| `updateUser` | Update user data |
+| `updateProfile` | Update user profile |
+| `updateRoles` | Update user roles |
+| `updateTags` | Update user tags |
+| `updateAvatar` | Set user avatar |
+| `updateBillingAddress` | Update billing address |
+| `updatePassword` | Change user password |
+| `updateUsername` | Change username |
+| `delete` | Soft delete a user |
+| `replaceUserId` | Migrate data between users |
+
+### Authentication
+
+| Method | Description |
+|--------|-------------|
+| `verifyPassword` | Verify password against stored hash |
+| `hashPassword` | Hash a password for storage |
+| `addEmail` | Add email address to user |
+| `removeEmail` | Remove email address |
+| `verifyEmail` | Mark email as verified |
+| `updateHeartbeat` | Update last activity timestamp |
+| `updateLastLogin` | Record login event |
+
+### WebAuthn Submodule
+
+| Method | Description |
+|--------|-------------|
+| `webAuthn.findCredentials` | Find WebAuthn credentials for user |
+| `webAuthn.createCredential` | Register new WebAuthn credential |
+| `webAuthn.removeCredential` | Remove WebAuthn credential |
+
+### Settings
+
+| Export | Description |
+|--------|-------------|
+| `userSettings` | Access user module settings |
+| `UserAccountAction` | Account action types enum |
+
+### Types
+
+| Export | Description |
+|--------|-------------|
+| `User` | User document type |
+| `UserQuery` | Query parameters type |
+| `UserProfile` | User profile type |
+| `Email` | Email address type |
+| `UsersModule` | Module interface type |
+| `UserSettingsOptions` | Configuration options type |
+
+## Events
+
+| Event | Description |
+|-------|-------------|
+| `USER_CREATE` | User created |
+| `USER_UPDATE` | User updated |
+| `USER_REMOVE` | User deleted |
+| `USER_UPDATE_PROFILE` | Profile updated |
+| `USER_UPDATE_PASSWORD` | Password changed |
+| `USER_UPDATE_ROLES` | Roles changed |
+| `USER_ACCOUNT_ACTION` | Account action triggered |
+
+## License
+
+EUPL-1.2

package/lib/db/UsersCollection.d.ts

@@ -1,5 +1,5 @@
-import { TimestampFields, Address, Contact, mongodb } from '@unchainedshop/mongodb';
-import { DateFilterInput } from '@unchainedshop/utils';
+import { type TimestampFields, type Address, type Contact, type mongodb } from '@unchainedshop/mongodb';
+import type { DateFilterInput } from '@unchainedshop/utils';
 export interface UserProfile {
     displayName?: string;
     birthday?: Date;
@@ -46,12 +46,15 @@ export type User = {
     username?: string;
     meta?: any;
 } & TimestampFields;
-export type UserQuery = mongodb.Filter<User> & {
+export interface UserQuery {
     includeGuests?: boolean;
     includeDeleted?: boolean;
     queryString?: string;
     emailVerified?: boolean;
     lastLogin?: DateFilterInput;
-};
+    tags?: string[];
+    userIds?: string[];
+    username?: string;
+    web3Verified?: boolean;
+}
 export declare const UsersCollection: (db: mongodb.Db) => Promise<mongodb.Collection<User>>;
-//# sourceMappingURL=UsersCollection.d.ts.map

package/lib/db/UsersCollection.js

@@ -99,4 +99,3 @@ export const UsersCollection = async (db) => {
     ]);
     return Users;
 };
-//# sourceMappingURL=UsersCollection.js.map

package/lib/db/WebAuthnCredentialsCreationRequestsCollection.d.ts

@@ -1,4 +1,4 @@
-import { mongodb } from '@unchainedshop/mongodb';
+import { type mongodb } from '@unchainedshop/mongodb';
 export interface WebAuthnCredentialsCreationRequest {
     challenge: string;
     username: string;
@@ -10,4 +10,3 @@ type Collection = WebAuthnCredentialsCreationRequest & {
 };
 export declare const WebAuthnCredentialsCreationRequestsCollection: (db: mongodb.Db) => Promise<mongodb.Collection<Collection>>;
 export {};
-//# sourceMappingURL=WebAuthnCredentialsCreationRequestsCollection.d.ts.map

package/lib/db/WebAuthnCredentialsCreationRequestsCollection.js

@@ -10,4 +10,3 @@ export const WebAuthnCredentialsCreationRequestsCollection = async (db) => {
     ]);
     return WebAuthnCredentialsCreationRequests;
 };
-//# sourceMappingURL=WebAuthnCredentialsCreationRequestsCollection.js.map

package/lib/migrations/20241218092300-convert-locale.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationRepository } from '@unchainedshop/mongodb';
+export default function convertUserLocale(repository: MigrationRepository): void;

package/lib/migrations/20241218092300-convert-locale.js

@@ -0,0 +1,36 @@
+import { UsersCollection } from "../db/UsersCollection.js";
+import { systemLocale } from '@unchainedshop/utils';
+export default function convertUserLocale(repository) {
+    repository?.register({
+        id: 20241218092300,
+        name: 'Convert user.lastLogin.locale',
+        up: async () => {
+            const Users = await UsersCollection(repository.db);
+            const users = await Users.find({
+                'lastLogin.locale': { $exists: true },
+            }, { projection: { _id: true, lastLogin: true } }).toArray();
+            for (const user of users) {
+                let newLocale;
+                const currentLocale = user.lastLogin?.locale;
+                if (!currentLocale)
+                    continue;
+                try {
+                    newLocale = new Intl.Locale(currentLocale).baseName;
+                }
+                catch {
+                    try {
+                        newLocale = new Intl.Locale(currentLocale.split('_').join('-')).baseName;
+                    }
+                    catch {
+                        newLocale = systemLocale.baseName;
+                    }
+                }
+                await Users.updateOne({
+                    _id: user._id,
+                }, {
+                    $set: { 'lastLogin.locale': newLocale },
+                });
+            }
+        },
+    });
+}

package/lib/module/configureUsersModule.d.ts

@@ -1,29 +1,42 @@
-import { ModuleInput, Address, Contact, mongodb } from '@unchainedshop/mongodb';
-import { User, UserQuery, Email, UserLastLogin, UserProfile } from '../db/UsersCollection.js';
-import { SortOption } from '@unchainedshop/utils';
-import { UserRegistrationData, UserSettingsOptions } from '../users-settings.js';
+import { type ModuleInput, type Address, type Contact, type mongodb } from '@unchainedshop/mongodb';
+import { type User, type UserQuery, type Email, type UserLastLogin, type UserProfile } from '../db/UsersCollection.ts';
+import { type SortOption } from '@unchainedshop/utils';
+import { type UserRegistrationData, type UserSettingsOptions } from '../users-settings.ts';
 export declare const removeConfidentialServiceHashes: (rawUser: User) => User;
-export declare const buildFindSelector: ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, ...rest }: UserQuery) => mongodb.Filter<User>;
+export declare const buildFindSelector: ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, userIds, username, web3Verified, }: UserQuery) => mongodb.Filter<User>;
 export declare const configureUsersModule: (moduleInput: ModuleInput<UserSettingsOptions>) => Promise<{
     webAuthn: {
-        findMDSMetadataForAAGUID: (aaguid: string) => Promise<any>;
-        createCredentialCreationOptions: (origin: string, username: string, extensionOptions?: any) => Promise<(Omit<import("fido2-lib").PublicKeyCredentialCreationOptions, "challenge" | "requestId"> & {
-            challenge: string;
-            requestId: number;
-        }) | null>;
-        createCredentialRequestOptions: (origin: string, username: string, extensionOptions?: any) => Promise<(Omit<import("fido2-lib").PublicKeyCredentialRequestOptions, "challenge" | "requestId"> & {
-            challenge: string;
-            requestId: number;
-        }) | null>;
-        verifyCredentialCreation: (username: string, credentials: any) => Promise<{
-            publicKey: any;
-            counter: any;
-            id: any;
-            aaguid: string;
-            created: Date;
+        findMDSMetadataForAAGUID: (aaguid: string) => Promise<{
+            [key: string]: unknown;
+            description?: string;
+            icon?: string;
+            authenticatorGetInfo?: {
+                versions?: string[];
+                extensions?: string[];
+                options?: Record<string, boolean>;
+            };
         } | null>;
-        verifyCredentialRequest: (userPublicKeys: any[], username: string, credentials: any) => Promise<{
-            userHandle: any;
+        createCredentialCreationOptions: (origin: string, username: string, extensionOptions?: {
+            timeout?: number;
+            authenticatorSelection?: import("./configureUsersWebAuthnModule.ts").WebAuthnCredentialCreationOptions["authenticatorSelection"];
+        }) => Promise<import("./configureUsersWebAuthnModule.ts").WebAuthnCredentialCreationOptions>;
+        createCredentialRequestOptions: (origin: string, username: string, extensionOptions?: {
+            timeout?: number;
+            userVerification?: "required" | "preferred" | "discouraged";
+            allowCredentials?: import("./configureUsersWebAuthnModule.ts").WebAuthnCredentialRequestOptions["allowCredentials"];
+        }) => Promise<import("./configureUsersWebAuthnModule.ts").WebAuthnCredentialRequestOptions>;
+        verifyCredentialCreation: (username: string, credentials: import("@passwordless-id/webauthn/dist/esm/types.js").RegistrationJSON) => Promise<import("./configureUsersWebAuthnModule.ts").WebAuthnCredential | null>;
+        verifyCredentialRequest: (userPublicKeys: {
+            id: string;
+            publicKey: string;
+            algorithm?: import("@passwordless-id/webauthn/dist/esm/types.js").NamedAlgo;
+            counter?: number;
+            transports?: import("@passwordless-id/webauthn/dist/esm/types.js").ExtendedAuthenticatorTransport[];
+        }[], username: string, credentials: import("@passwordless-id/webauthn/dist/esm/types.js").AuthenticationJSON & {
+            requestId: number;
+        }) => Promise<{
+            userHandle: string;
+            counter: number;
         } | null>;
         deleteUserWebAuthnCredentials: (username: string) => Promise<number>;
     };
@@ -69,6 +82,24 @@ export declare const configureUsersModule: (moduleInput: ModuleInput<UserSetting
     }, plainPassword: string): Promise<boolean>;
     addEmail(userId: string, address: string): Promise<void>;
     removeEmail(userId: string, address: string): Promise<void>;
+    addWeb3Address(userId: string, address: string): Promise<User | null>;
+    removeWeb3Address(userId: string, address: string): Promise<User | null>;
+    findWeb3Address(user: User, address: string): {
+        address: string;
+        nonce?: string;
+        verified?: boolean;
+    } | null;
+    addWebAuthnCredential(userId: string, webAuthnService: {
+        id: string;
+        publicKey: string;
+        created: Date;
+    }): Promise<User | null>;
+    removeWebAuthnCredential(userId: string, credentialsId: string): Promise<User | null>;
+    setAccessToken(username: string, plainSecret: string): Promise<User | null>;
+    verifyWeb3SignatureAndUpdate(user: User, credentials: {
+        address: string;
+        nonce: string;
+    }, signature: `0x${string}`): Promise<User | null>;
     sendResetPasswordEmail(userId: string, email: string, isEnrollment?: boolean): Promise<void>;
     sendVerificationEmail(userId: string, email: string): Promise<void>;
     addRoles: (userId: string, roles: string[]) => Promise<mongodb.WithId<User> | null>;
@@ -99,4 +130,3 @@ export declare const configureUsersModule: (moduleInput: ModuleInput<UserSetting
     existingTags: () => Promise<string[]>;
 }>;
 export type UsersModule = Awaited<ReturnType<typeof configureUsersModule>>;
-//# sourceMappingURL=configureUsersModule.d.ts.map

package/lib/module/configureUsersModule.js

@@ -1,11 +1,13 @@
 import * as bcrypt from 'bcryptjs';
 import { generateDbFilterById, buildSortOptions, generateDbObjectId, insensitiveTrimmedRegexOperator, assertDocumentDBCompatMode, } from '@unchainedshop/mongodb';
-import { UsersCollection, } from '../db/UsersCollection.js';
+import { UsersCollection, } from "../db/UsersCollection.js";
 import { emit, registerEvents } from '@unchainedshop/events';
 import { systemLocale, SortDirection, sha256 } from '@unchainedshop/utils';
-import { UserAccountAction, userSettings, } from '../users-settings.js';
-import { configureUsersWebAuthnModule } from './configureUsersWebAuthnModule.js';
-import * as pbkdf2 from './pbkdf2.js';
+import { UserAccountAction, userSettings, } from "../users-settings.js";
+import { configureUsersWebAuthnModule } from "./configureUsersWebAuthnModule.js";
+import * as pbkdf2 from "./pbkdf2.js";
+import { verifyWeb3Signature } from "../utils/web3-verification.js";
+import convertUserLocale from "../migrations/20241218092300-convert-locale.js";
 const USER_EVENTS = [
     'USER_ACCOUNT_ACTION',
     'USER_CREATE',
@@ -21,6 +23,7 @@ const USER_EVENTS = [
     'USER_UPDATE_HEARTBEAT',
     'USER_UPDATE_BILLING_ADDRESS',
     'USER_UPDATE_LAST_CONTACT',
+    'USER_UPDATE_WEB3_ADDRESS',
     'USER_REMOVE',
 ];
 export const removeConfidentialServiceHashes = (rawUser) => {
@@ -28,12 +31,18 @@ export const removeConfidentialServiceHashes = (rawUser) => {
     delete user?.services;
     return user;
 };
-export const buildFindSelector = ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, ...rest }) => {
-    const selector = { ...rest };
+export const buildFindSelector = ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, userIds, username, web3Verified, }) => {
+    const selector = {};
     if (!includeDeleted)
         selector.deleted = null;
     if (!includeGuests)
         selector.guest = { $ne: true };
+    if (userIds) {
+        selector._id = { $in: userIds };
+    }
+    if (username) {
+        selector.username = insensitiveTrimmedRegexOperator(username);
+    }
     if (emailVerified === true) {
         selector['emails.verified'] = true;
     }
@@ -41,10 +50,11 @@ export const buildFindSelector = ({ includeGuests, includeDeleted, queryString,
         selector.tags = { $in: tags };
     }
     if (emailVerified === false) {
-        // We need to use $ne here else we'd also find users with many emails where one is
-        // unverified
         selector['emails.verified'] = { $ne: true };
     }
+    if (web3Verified === true) {
+        selector['services.web3.verified'] = true;
+    }
     if (lastLogin?.start) {
         selector['lastLogin.timestamp'] = { $exists: true };
     }
@@ -61,13 +71,13 @@ export const buildFindSelector = ({ includeGuests, includeDeleted, queryString,
     return selector;
 };
 export const configureUsersModule = async (moduleInput) => {
-    const { db, options } = moduleInput;
+    const { db, options, migrationRepository } = moduleInput;
+    convertUserLocale(migrationRepository);
     userSettings.configureSettings(options || {}, db);
     registerEvents(USER_EVENTS);
     const Users = await UsersCollection(db);
     const webAuthn = await configureUsersWebAuthnModule(moduleInput);
     return {
-        // Queries
         webAuthn,
         async count(query) {
             const userCount = await Users.countDocuments(buildFindSelector(query));
@@ -182,7 +192,6 @@ export const configureUsersModule = async (moduleInput) => {
             const userCount = await Users.countDocuments({ _id: userId, deleted: { $exists: false } }, { limit: 1 });
             return userCount === 1;
         },
-        // Transformations
         primaryEmail(user) {
             return (user.emails || []).toSorted((left, right) => Number(right.verified) - Number(left.verified))?.[0];
         },
@@ -196,11 +205,13 @@ export const configureUsersModule = async (moduleInput) => {
                 return systemLocale;
             }
         },
-        // Mutations
         async createUser(rawUserData, { skipMessaging, skipPasswordEnrollment, } = {}) {
             const { password, email, username, initialPassword, roles, webAuthnPublicKeyCredentials, ...userData } = await userSettings.validateNewUser(rawUserData);
             const webAuthnService = webAuthnPublicKeyCredentials &&
                 (await this.webAuthn.verifyCredentialCreation(username, webAuthnPublicKeyCredentials));
+            if (webAuthnPublicKeyCredentials && !webAuthnService) {
+                throw new Error('WebAuthn credential verification failed', { cause: 'WEBAUTHN_INVALID' });
+            }
             const services = {};
             if (email) {
                 if (!(await userSettings.validateEmail(email))) {
@@ -250,7 +261,6 @@ export const configureUsersModule = async (moduleInput) => {
                 }
             }
             catch {
-                /* */
             }
             const user = (await Users.findOne({ _id: userId }, {}));
             await emit('USER_CREATE', {
@@ -294,6 +304,110 @@ export const configureUsersModule = async (moduleInput) => {
                 },
             });
         },
+        async addWeb3Address(userId, address) {
+            const user = await Users.findOne(generateDbFilterById(userId), {});
+            if (!user)
+                return null;
+            const existingEntry = user.services?.web3?.find((service) => service.address.toLowerCase() === address.toLowerCase());
+            if (existingEntry)
+                return user;
+            const nonce = Math.floor(Math.random() * 1000000).toString();
+            const updatedUser = await Users.findOneAndUpdate(generateDbFilterById(userId), {
+                $push: {
+                    'services.web3': {
+                        address,
+                        nonce,
+                    },
+                },
+            }, { returnDocument: 'after' });
+            if (!updatedUser)
+                return null;
+            await emit('USER_UPDATE_WEB3_ADDRESS', {
+                action: 'add',
+                address,
+                user: removeConfidentialServiceHashes(updatedUser),
+            });
+            return updatedUser;
+        },
+        async removeWeb3Address(userId, address) {
+            const user = await Users.findOne(generateDbFilterById(userId), {});
+            if (!user)
+                return null;
+            const existingEntry = user.services?.web3?.find((service) => service.address.toLowerCase() === address.toLowerCase());
+            if (!existingEntry)
+                return null;
+            const updatedUser = await Users.findOneAndUpdate(generateDbFilterById(userId), {
+                $pull: {
+                    'services.web3': { address: existingEntry.address },
+                },
+            }, { returnDocument: 'after' });
+            if (!updatedUser)
+                return null;
+            await emit('USER_UPDATE_WEB3_ADDRESS', {
+                action: 'remove',
+                address: existingEntry.address,
+                user: removeConfidentialServiceHashes(updatedUser),
+            });
+            return updatedUser;
+        },
+        findWeb3Address(user, address) {
+            return (user.services?.web3?.find((service) => service.address.toLowerCase() === address.toLowerCase()) || null);
+        },
+        async addWebAuthnCredential(userId, webAuthnService) {
+            const updatedUser = await Users.findOneAndUpdate(generateDbFilterById(userId), {
+                $push: {
+                    'services.webAuthn': webAuthnService,
+                },
+            }, { returnDocument: 'after' });
+            return updatedUser;
+        },
+        async removeWebAuthnCredential(userId, credentialsId) {
+            const updatedUser = await Users.findOneAndUpdate(generateDbFilterById(userId), {
+                $pull: {
+                    'services.webAuthn': { id: credentialsId },
+                },
+            }, { returnDocument: 'after' });
+            return updatedUser;
+        },
+        async setAccessToken(username, plainSecret) {
+            const secret = await sha256(`${username}:${plainSecret}`);
+            const updatedUser = await Users.findOneAndUpdate({ username: insensitiveTrimmedRegexOperator(username) }, {
+                $set: {
+                    'services.token': { secret },
+                },
+            }, { returnDocument: 'after' });
+            return updatedUser;
+        },
+        async verifyWeb3SignatureAndUpdate(user, credentials, signature) {
+            const isValid = await verifyWeb3Signature(credentials.nonce, signature, credentials.address);
+            if (!isValid)
+                return null;
+            const web3Services = user.services?.web3?.map((service) => {
+                if (service.address.toLowerCase() === credentials.address.toLowerCase()) {
+                    return {
+                        ...service,
+                        nonce: undefined,
+                        verified: true,
+                    };
+                }
+                return service;
+            });
+            if (!web3Services)
+                return null;
+            const updatedUser = await Users.findOneAndUpdate(generateDbFilterById(user._id), {
+                $set: {
+                    'services.web3': web3Services,
+                },
+            }, { returnDocument: 'after' });
+            if (!updatedUser)
+                return null;
+            await emit('USER_UPDATE_WEB3_ADDRESS', {
+                action: 'verify',
+                address: credentials.address,
+                user: removeConfidentialServiceHashes(updatedUser),
+            });
+            return updatedUser;
+        },
         async sendResetPasswordEmail(userId, email, isEnrollment) {
             const plainToken = crypto.randomUUID();
             const resetToken = {
@@ -384,7 +498,6 @@ export const configureUsersModule = async (moduleInput) => {
                 return null;
             const updatedUser = await this.setPassword(resetToken.userId, newPassword);
             if (updatedUser) {
-                // Now invalidate the reset token
                 await Users.updateOne({
                     _id: resetToken.userId,
                 }, {
@@ -500,8 +613,6 @@ export const configureUsersModule = async (moduleInput) => {
                 }, {});
             }
             if (meta) {
-                // eslint-disable-next-line
-                // @ts-ignore
                 modifier.$set.meta = meta;
             }
             const user = await Users.findOneAndUpdate(userFilter, modifier, {
@@ -561,7 +672,6 @@ export const configureUsersModule = async (moduleInput) => {
                 },
             };
             if ((!profile.phoneMobile || isGuest) && lastContact.telNumber) {
-                // Backport the contact phone number to the user profile
                 modifier.$set['profile.phoneMobile'] = lastContact.telNumber;
             }
             const updatedUser = await Users.findOneAndUpdate(userFilter, modifier, {
@@ -652,4 +762,3 @@ export const configureUsersModule = async (moduleInput) => {
         },
     };
 };
-//# sourceMappingURL=configureUsersModule.js.map

package/lib/module/configureUsersWebAuthnModule.d.ts

@@ -1,26 +1,84 @@
-import { ModuleInput } from '@unchainedshop/mongodb';
-import type { PublicKeyCredentialCreationOptions, PublicKeyCredentialRequestOptions } from 'fido2-lib';
-type SerializedOptions<T> = Omit<T, 'challenge' | 'requestId'> & {
+import type { ModuleInput } from '@unchainedshop/mongodb';
+import type { RegistrationJSON, AuthenticationJSON, CredentialInfo, NamedAlgo, ExtendedAuthenticatorTransport } from '@passwordless-id/webauthn/dist/esm/types.js';
+export type { RegistrationJSON, AuthenticationJSON, CredentialInfo, NamedAlgo, ExtendedAuthenticatorTransport, };
+export declare function toArrayBuffer(buffer: Buffer): ArrayBuffer;
+export declare function buf2hex(buffer: ArrayBuffer): string;
+export interface WebAuthnCredentialCreationOptions {
     challenge: string;
     requestId: number;
-};
-export declare function toArrayBuffer(buffer: any): any;
-export declare function buf2hex(buffer: any): string;
-export declare const configureUsersWebAuthnModule: ({ db }: ModuleInput<any>) => Promise<{
-    findMDSMetadataForAAGUID: (aaguid: string) => Promise<any>;
-    createCredentialCreationOptions: (origin: string, username: string, extensionOptions?: any) => Promise<SerializedOptions<PublicKeyCredentialCreationOptions> | null>;
-    createCredentialRequestOptions: (origin: string, username: string, extensionOptions?: any) => Promise<SerializedOptions<PublicKeyCredentialRequestOptions> | null>;
-    verifyCredentialCreation: (username: string, credentials: any) => Promise<{
-        publicKey: any;
-        counter: any;
-        id: any;
-        aaguid: string;
-        created: Date;
+    rp: {
+        id: string;
+        name: string;
+    };
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+    };
+    pubKeyCredParams: {
+        type: 'public-key';
+        alg: number;
+    }[];
+    timeout: number;
+    attestation: 'none' | 'indirect' | 'direct';
+    authenticatorSelection?: {
+        authenticatorAttachment?: 'platform' | 'cross-platform';
+        requireResidentKey?: boolean;
+        userVerification?: 'required' | 'preferred' | 'discouraged';
+    };
+}
+export interface WebAuthnCredentialRequestOptions {
+    challenge: string;
+    requestId: number;
+    rpId: string;
+    timeout: number;
+    userVerification?: 'required' | 'preferred' | 'discouraged';
+    allowCredentials?: {
+        id: string;
+        type: 'public-key';
+        transports?: ('usb' | 'nfc' | 'ble' | 'internal')[];
+    }[];
+}
+export interface WebAuthnCredential {
+    id: string;
+    publicKey: string;
+    algorithm: NamedAlgo;
+    aaguid: string;
+    counter: number;
+    created: Date;
+}
+export declare const configureUsersWebAuthnModule: ({ db }: ModuleInput<Record<string, any>>) => Promise<{
+    findMDSMetadataForAAGUID: (aaguid: string) => Promise<{
+        [key: string]: unknown;
+        description?: string;
+        icon?: string;
+        authenticatorGetInfo?: {
+            versions?: string[];
+            extensions?: string[];
+            options?: Record<string, boolean>;
+        };
     } | null>;
-    verifyCredentialRequest: (userPublicKeys: any[], username: string, credentials: any) => Promise<{
-        userHandle: any;
+    createCredentialCreationOptions: (origin: string, username: string, extensionOptions?: {
+        timeout?: number;
+        authenticatorSelection?: WebAuthnCredentialCreationOptions["authenticatorSelection"];
+    }) => Promise<WebAuthnCredentialCreationOptions>;
+    createCredentialRequestOptions: (origin: string, username: string, extensionOptions?: {
+        timeout?: number;
+        userVerification?: "required" | "preferred" | "discouraged";
+        allowCredentials?: WebAuthnCredentialRequestOptions["allowCredentials"];
+    }) => Promise<WebAuthnCredentialRequestOptions>;
+    verifyCredentialCreation: (username: string, credentials: RegistrationJSON) => Promise<WebAuthnCredential | null>;
+    verifyCredentialRequest: (userPublicKeys: {
+        id: string;
+        publicKey: string;
+        algorithm?: NamedAlgo;
+        counter?: number;
+        transports?: ExtendedAuthenticatorTransport[];
+    }[], username: string, credentials: AuthenticationJSON & {
+        requestId: number;
+    }) => Promise<{
+        userHandle: string;
+        counter: number;
     } | null>;
     deleteUserWebAuthnCredentials: (username: string) => Promise<number>;
 }>;
-export {};
-//# sourceMappingURL=configureUsersWebAuthnModule.d.ts.map