@adonisjs/auth/build/modules/session_guard/user_providers/lucid.d.ts

Official authentication provider for Adonis framework

import { type Secret } from '@adonisjs/core/helpers';
import { type RememberMeToken } from '../remember_me_token.ts';
import { PROVIDER_REAL_USER } from '../../../src/symbols.ts';
import type { SessionGuardUser, LucidAuthenticatable, SessionLucidUserProviderOptions, SessionUserProviderContract } from '../types.ts';
/**
 * Uses a lucid model to verify access tokens and find a user during
 * authentication
 *
 * @template UserModel - The Lucid model representing the user
 *
 * @example
 * const userProvider = new SessionLucidUserProvider({
 *   model: () => import('#models/user')
 * })
 */
export declare class SessionLucidUserProvider<UserModel extends LucidAuthenticatable> implements SessionUserProviderContract<InstanceType<UserModel>> {
    /**
     * Lucid provider options
     */
    protected options: SessionLucidUserProviderOptions<UserModel>;
    [PROVIDER_REAL_USER]: InstanceType<UserModel>;
    /**
     * Reference to the lazily imported model
     */
    protected model?: UserModel;
    /**
     * Creates a new SessionLucidUserProvider instance
     *
     * @param options - Configuration options for the user provider
     *
     * @example
     * const provider = new SessionLucidUserProvider({
     *   model: () => import('#models/user')
     * })
     */
    constructor(
    /**
     * Lucid provider options
     */
    options: SessionLucidUserProviderOptions<UserModel>);
    /**
     * Imports the model from the provider, returns and caches it
     * for further operations.
     *
     * @example
     * const UserModel = await provider.getModel()
     * const user = await UserModel.find(1)
     */
    protected getModel(): Promise<UserModel>;
    /**
     * Returns the tokens provider associated with the user model
     *
     * @example
     * const tokensProvider = await provider.getTokensProvider()
     * const token = await tokensProvider.create(user, '7d')
     */
    protected getTokensProvider(): Promise<import("../types.ts").RememberMeTokensProviderContract<import("@adonisjs/lucid/types/model").LucidModel>>;
    /**
     * Creates an adapter user for the guard
     *
     * @param user - The user model instance
     *
     * @example
     * const guardUser = await provider.createUserForGuard(user)
     * console.log('User ID:', guardUser.getId())
     * console.log('Original user:', guardUser.getOriginal())
     */
    createUserForGuard(user: InstanceType<UserModel>): Promise<SessionGuardUser<InstanceType<UserModel>>>;
    /**
     * Finds a user by their primary key value
     *
     * @param identifier - The user identifier to search for
     *
     * @example
     * const guardUser = await provider.findById(123)
     * if (guardUser) {
     *   const originalUser = guardUser.getOriginal()
     *   console.log('Found user:', originalUser.email)
     * }
     */
    findById(identifier: string | number | BigInt): Promise<SessionGuardUser<InstanceType<UserModel>> | null>;
    /**
     * Creates a remember token for a given user
     *
     * @param user - The user to create a token for
     * @param expiresIn - Token expiration time
     *
     * @example
     * const token = await provider.createRememberToken(user, '30d')
     * console.log('Remember token:', token.value.release())
     */
    createRememberToken(user: InstanceType<UserModel>, expiresIn: string | number): Promise<RememberMeToken>;
    /**
     * Verify a token by its publicly shared value
     *
     * @param tokenValue - The token value to verify
     *
     * @example
     * const token = await provider.verifyRememberToken(
     *   new Secret('rmt_abc123.def456')
     * )
     * if (token && !token.isExpired()) {
     *   console.log('Valid remember token for user:', token.tokenableId)
     * }
     */
    verifyRememberToken(tokenValue: Secret<string>): Promise<RememberMeToken | null>;
    /**
     * Delete a token for a user by the token identifier
     *
     * @param user - The user that owns the token
     * @param identifier - The token identifier to delete
     *
     * @example
     * const deletedCount = await provider.deleteRemeberToken(user, 123)
     * console.log('Deleted tokens:', deletedCount)
     */
    deleteRemeberToken(user: InstanceType<UserModel>, identifier: string | number | BigInt): Promise<number>;
    /**
     * Recycle a token for a user by the token identifier
     *
     * @param user - The user that owns the token
     * @param identifier - The token identifier to recycle
     * @param expiresIn - New expiration time
     *
     * @example
     * const newToken = await provider.recycleRememberToken(user, 123, '30d')
     * console.log('Recycled token:', newToken.value.release())
     */
    recycleRememberToken(user: InstanceType<UserModel>, identifier: string | number | BigInt, expiresIn: string | number): Promise<RememberMeToken>;
}