import type { Secret } from '@adonisjs/core/helpers';
import type { LucidModel } from '@adonisjs/lucid/types/model';
import { RememberMeToken } from '../remember_me_token.ts';
import type { RememberMeTokenDbColumns, RememberMeTokensProviderContract, DbRememberMeTokensProviderOptions } from '../types.ts';
/**
 * DbRememberMeTokensProvider uses lucid database service to fetch and
 * persist tokens for a given user.
 *
 * The user must be an instance of the associated user model.
 *
 * @template TokenableModel - The Lucid model that can have remember me tokens
 *
 * @example
 * const provider = new DbRememberMeTokensProvider({
 *   tokenableModel: () => import('#models/user'),
 *   table: 'remember_me_tokens',
 *   tokenSecretLength: 32
 * })
 */
export declare class DbRememberMeTokensProvider<TokenableModel extends LucidModel> implements RememberMeTokensProviderContract<TokenableModel> {
    #private;
    protected options: DbRememberMeTokensProviderOptions<TokenableModel>;
    /**
     * Create tokens provider instance for a given Lucid model
     *
     * @param model - The tokenable model factory function
     * @param options - Optional configuration options
     *
     * @example
     * const provider = DbRememberMeTokensProvider.forModel(
     *   () => import('#models/user'),
     *   { table: 'user_remember_tokens' }
     * )
     */
    static forModel<TokenableModel extends LucidModel>(model: DbRememberMeTokensProviderOptions<TokenableModel>['tokenableModel'], options?: Omit<DbRememberMeTokensProviderOptions<TokenableModel>, 'tokenableModel'>): DbRememberMeTokensProvider<TokenableModel>;
    /**
     * Database table to use for querying remember me tokens
     */
    protected table: string;
    /**
     * The length for the token secret. A secret is a cryptographically
     * secure random string.
     */
    protected tokenSecretLength: number;
    /**
     * Creates a new DbRememberMeTokensProvider instance
     *
     * @param options - Configuration options for the provider
     *
     * @example
     * const provider = new DbRememberMeTokensProvider({
     *   tokenableModel: () => import('#models/user'),
     *   table: 'remember_me_tokens',
     *   tokenSecretLength: 40
     * })
     */
    constructor(options: DbRememberMeTokensProviderOptions<TokenableModel>);
    /**
     * Maps a database row to an instance token instance
     *
     * @param dbRow - The database row containing token data
     *
     * @example
     * const token = provider.dbRowToRememberMeToken({
     *   id: 1,
     *   tokenable_id: 123,
     *   hash: 'sha256hash',
     *   // ... other columns
     * })
     */
    protected dbRowToRememberMeToken(dbRow: RememberMeTokenDbColumns): RememberMeToken;
    /**
     * Returns a query client instance from the parent model
     *
     * @example
     * const db = await provider.getDb()
     * const tokens = await db.from('remember_me_tokens').select('*')
     */
    protected getDb(): Promise<import("@adonisjs/lucid/types/database").QueryClientContract>;
    /**
     * Create a token for a user
     *
     * @param user - The user instance to create a token for
     * @param expiresIn - Token expiration time
     *
     * @example
     * const token = await provider.create(user, '30d')
     * console.log('Remember token:', token.value.release())
     */
    create(user: InstanceType<TokenableModel>, expiresIn: string | number): Promise<RememberMeToken>;
    /**
     * Find a token for a user by the token id
     *
     * @param user - The user instance that owns the token
     * @param identifier - The token identifier to search for
     *
     * @example
     * const token = await provider.find(user, 123)
     * if (token) {
     *   console.log('Found token with id:', token.identifier)
     * }
     */
    find(user: InstanceType<TokenableModel>, identifier: string | number | BigInt): Promise<RememberMeToken | null>;
    /**
     * Delete a token by its id
     *
     * @param user - The user instance that owns the token
     * @param identifier - The token identifier to delete
     *
     * @example
     * const deletedCount = await provider.delete(user, 123)
     * console.log('Deleted tokens:', deletedCount)
     */
    delete(user: InstanceType<TokenableModel>, identifier: string | number | BigInt): Promise<number>;
    /**
     * Returns all the tokens a given user
     *
     * @param user - The user instance to get tokens for
     *
     * @example
     * const tokens = await provider.all(user)
     * console.log('User has', tokens.length, 'remember tokens')
     * tokens.forEach(token => console.log(token.identifier))
     */
    all(user: InstanceType<TokenableModel>): Promise<RememberMeToken[]>;
    /**
     * Verifies a publicly shared remember me token and returns an
     * RememberMeToken for it.
     *
     * Returns null when unable to verify the token or find it
     * inside the storage
     *
     * @param tokenValue - The token value to verify
     *
     * @example
     * const token = await provider.verify(new Secret('rmt_abc123.def456'))
     * if (token && !token.isExpired()) {
     *   console.log('Valid remember token for user:', token.tokenableId)
     * }
     */
    verify(tokenValue: Secret<string>): Promise<RememberMeToken | null>;
    /**
     * Recycles a remember me token by deleting the old one and
     * creates a new one.
     *
     * Ideally, the recycle should update the existing token, but we
     * skip that for now and come back to it later and handle race
     * conditions as well.
     *
     * @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.recycle(user, 123, '30d')
     * console.log('Recycled token:', newToken.value.release())
     */
    recycle(user: InstanceType<TokenableModel>, identifier: string | number | BigInt, expiresIn: string | number): Promise<RememberMeToken>;
}