/**
 * WebAuthn/Passkey Authentication Type Definitions
 *
 * Defines types, interfaces, and Zod schemas for WebAuthn credential management,
 * registration, and authentication flows.
 *
 * @packageDocumentation
 */
import { z } from 'zod';
import type { PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON, RegistrationResponseJSON, AuthenticationResponseJSON, AuthenticatorTransportFuture } from '@simplewebauthn/types';
/**
 * Authenticator transport types supported by WebAuthn
 */
export type AuthenticatorTransport = AuthenticatorTransportFuture;
export declare const authenticatorTransportSchema: z.ZodEnum<["usb", "ble", "nfc", "internal", "cable", "hybrid", "smart-card"]>;
/**
 * Stored WebAuthn credential
 */
export interface WebAuthnCredential {
    /** Internal unique identifier (UUID) */
    id: string;
    /** Base64URL encoded credential ID from authenticator */
    credentialId: string;
    /** Base64URL encoded public key */
    publicKey: string;
    /** Signature counter for replay attack prevention */
    counter: number;
    /** Supported transport methods */
    transports?: AuthenticatorTransport[];
    /** Timestamp when credential was created */
    createdAt: Date;
    /** Timestamp of last successful authentication */
    lastUsedAt: Date | null;
    /** User-friendly name for the credential */
    name: string;
    /** User ID that owns this credential */
    userId: string;
    /** Type of device (e.g., 'singleDevice', 'multiDevice') */
    deviceType?: string;
    /** Whether credential is backed up (e.g., iCloud Keychain) */
    backedUp?: boolean;
    /** AAGUID of the authenticator (if available) */
    aaguid?: string;
}
export declare const webAuthnCredentialSchema: z.ZodObject<{
    id: z.ZodString;
    credentialId: z.ZodString;
    publicKey: z.ZodString;
    counter: z.ZodNumber;
    transports: z.ZodOptional<z.ZodArray<z.ZodEnum<["usb", "ble", "nfc", "internal", "cable", "hybrid", "smart-card"]>, "many">>;
    createdAt: z.ZodDate;
    lastUsedAt: z.ZodNullable<z.ZodDate>;
    name: z.ZodString;
    userId: z.ZodString;
    deviceType: z.ZodOptional<z.ZodString>;
    backedUp: z.ZodOptional<z.ZodBoolean>;
    aaguid: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    credentialId?: string;
    publicKey?: string;
    counter?: number;
    transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
    createdAt?: Date;
    lastUsedAt?: Date;
    name?: string;
    userId?: string;
    deviceType?: string;
    backedUp?: boolean;
    aaguid?: string;
}, {
    id?: string;
    credentialId?: string;
    publicKey?: string;
    counter?: number;
    transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
    createdAt?: Date;
    lastUsedAt?: Date;
    name?: string;
    userId?: string;
    deviceType?: string;
    backedUp?: boolean;
    aaguid?: string;
}>;
/**
 * Input for generating registration options
 */
export interface GenerateRegistrationOptionsInput {
    /** User ID to register the credential for */
    userId: string;
    /** User display name (usually email or username) */
    userName: string;
    /** User display name shown during registration */
    userDisplayName?: string;
    /** Optional preferred authenticator type */
    authenticatorType?: 'platform' | 'cross-platform';
    /** Whether to require user verification */
    requireUserVerification?: boolean;
}
export declare const generateRegistrationOptionsInputSchema: z.ZodObject<{
    userId: z.ZodString;
    userName: z.ZodString;
    userDisplayName: z.ZodOptional<z.ZodString>;
    authenticatorType: z.ZodOptional<z.ZodEnum<["platform", "cross-platform"]>>;
    requireUserVerification: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    userName?: string;
    userDisplayName?: string;
    authenticatorType?: "platform" | "cross-platform";
    requireUserVerification?: boolean;
}, {
    userId?: string;
    userName?: string;
    userDisplayName?: string;
    authenticatorType?: "platform" | "cross-platform";
    requireUserVerification?: boolean;
}>;
/**
 * Registration options returned to client
 */
export interface RegistrationOptions {
    /** The options to pass to navigator.credentials.create() */
    options: PublicKeyCredentialCreationOptionsJSON;
    /** Challenge for verification (stored server-side) */
    challenge: string;
}
export declare const registrationOptionsSchema: z.ZodObject<{
    options: z.ZodAny;
    challenge: z.ZodString;
}, "strip", z.ZodTypeAny, {
    options?: any;
    challenge?: string;
}, {
    options?: any;
    challenge?: string;
}>;
/**
 * Input for verifying registration
 */
export interface VerifyRegistrationInput {
    /** User ID that initiated registration */
    userId: string;
    /** Response from navigator.credentials.create() */
    response: RegistrationResponseJSON;
    /** Optional credential name */
    credentialName?: string;
}
export declare const verifyRegistrationInputSchema: z.ZodObject<{
    userId: z.ZodString;
    response: z.ZodAny;
    credentialName: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    response?: any;
    credentialName?: string;
}, {
    userId?: string;
    response?: any;
    credentialName?: string;
}>;
/**
 * Result of successful registration
 */
export interface RegistrationResult {
    /** Whether registration was successful */
    verified: boolean;
    /** The created credential (if successful) */
    credential?: WebAuthnCredential;
    /** Error message (if failed) */
    error?: string;
    /** Error code for programmatic handling */
    errorCode?: RegistrationErrorCode;
}
/**
 * Registration error codes
 */
export declare const RegistrationErrorCode: {
    /** Challenge not found or expired */
    readonly CHALLENGE_NOT_FOUND: "CHALLENGE_NOT_FOUND";
    /** Challenge has expired */
    readonly CHALLENGE_EXPIRED: "CHALLENGE_EXPIRED";
    /** Verification failed */
    readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
    /** Credential already exists */
    readonly CREDENTIAL_EXISTS: "CREDENTIAL_EXISTS";
    /** Invalid response format */
    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
    /** User not found */
    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
};
export type RegistrationErrorCode = (typeof RegistrationErrorCode)[keyof typeof RegistrationErrorCode];
export declare const registrationResultSchema: z.ZodObject<{
    verified: z.ZodBoolean;
    credential: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        credentialId: z.ZodString;
        publicKey: z.ZodString;
        counter: z.ZodNumber;
        transports: z.ZodOptional<z.ZodArray<z.ZodEnum<["usb", "ble", "nfc", "internal", "cable", "hybrid", "smart-card"]>, "many">>;
        createdAt: z.ZodDate;
        lastUsedAt: z.ZodNullable<z.ZodDate>;
        name: z.ZodString;
        userId: z.ZodString;
        deviceType: z.ZodOptional<z.ZodString>;
        backedUp: z.ZodOptional<z.ZodBoolean>;
        aaguid: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    }, {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    }>>;
    error: z.ZodOptional<z.ZodString>;
    errorCode: z.ZodOptional<z.ZodNativeEnum<{
        /** Challenge not found or expired */
        readonly CHALLENGE_NOT_FOUND: "CHALLENGE_NOT_FOUND";
        /** Challenge has expired */
        readonly CHALLENGE_EXPIRED: "CHALLENGE_EXPIRED";
        /** Verification failed */
        readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
        /** Credential already exists */
        readonly CREDENTIAL_EXISTS: "CREDENTIAL_EXISTS";
        /** Invalid response format */
        readonly INVALID_RESPONSE: "INVALID_RESPONSE";
        /** User not found */
        readonly USER_NOT_FOUND: "USER_NOT_FOUND";
    }>>;
}, "strip", z.ZodTypeAny, {
    verified?: boolean;
    credential?: {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    };
    error?: string;
    errorCode?: "CHALLENGE_NOT_FOUND" | "CHALLENGE_EXPIRED" | "VERIFICATION_FAILED" | "CREDENTIAL_EXISTS" | "INVALID_RESPONSE" | "USER_NOT_FOUND";
}, {
    verified?: boolean;
    credential?: {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    };
    error?: string;
    errorCode?: "CHALLENGE_NOT_FOUND" | "CHALLENGE_EXPIRED" | "VERIFICATION_FAILED" | "CREDENTIAL_EXISTS" | "INVALID_RESPONSE" | "USER_NOT_FOUND";
}>;
/**
 * Input for generating authentication options
 */
export interface GenerateAuthenticationOptionsInput {
    /** User ID to authenticate (optional for resident credentials) */
    userId?: string;
    /** Whether to require user verification */
    requireUserVerification?: boolean;
}
export declare const generateAuthenticationOptionsInputSchema: z.ZodObject<{
    userId: z.ZodOptional<z.ZodString>;
    requireUserVerification: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    requireUserVerification?: boolean;
}, {
    userId?: string;
    requireUserVerification?: boolean;
}>;
/**
 * Authentication options returned to client
 */
export interface AuthenticationOptions {
    /** The options to pass to navigator.credentials.get() */
    options: PublicKeyCredentialRequestOptionsJSON;
    /** Challenge for verification (stored server-side) */
    challenge: string;
}
export declare const authenticationOptionsSchema: z.ZodObject<{
    options: z.ZodAny;
    challenge: z.ZodString;
}, "strip", z.ZodTypeAny, {
    options?: any;
    challenge?: string;
}, {
    options?: any;
    challenge?: string;
}>;
/**
 * Input for verifying authentication
 */
export interface VerifyAuthenticationInput {
    /** User ID being authenticated */
    userId: string;
    /** Response from navigator.credentials.get() */
    response: AuthenticationResponseJSON;
}
export declare const verifyAuthenticationInputSchema: z.ZodObject<{
    userId: z.ZodString;
    response: z.ZodAny;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    response?: any;
}, {
    userId?: string;
    response?: any;
}>;
/**
 * Result of authentication verification
 */
export interface AuthenticationResult {
    /** Whether authentication was successful */
    verified: boolean;
    /** The credential used (if successful) */
    credential?: WebAuthnCredential;
    /** User ID (if successful) */
    userId?: string;
    /** Error message (if failed) */
    error?: string;
    /** Error code for programmatic handling */
    errorCode?: AuthenticationErrorCode;
}
/**
 * Authentication error codes
 */
export declare const AuthenticationErrorCode: {
    /** Challenge not found or expired */
    readonly CHALLENGE_NOT_FOUND: "CHALLENGE_NOT_FOUND";
    /** Challenge has expired */
    readonly CHALLENGE_EXPIRED: "CHALLENGE_EXPIRED";
    /** Credential not found */
    readonly CREDENTIAL_NOT_FOUND: "CREDENTIAL_NOT_FOUND";
    /** Verification failed */
    readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
    /** Counter rollback detected (potential cloned authenticator) */
    readonly COUNTER_ROLLBACK: "COUNTER_ROLLBACK";
    /** User has no credentials */
    readonly NO_CREDENTIALS: "NO_CREDENTIALS";
    /** Invalid response format */
    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
    /** User not found */
    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
};
export type AuthenticationErrorCode = (typeof AuthenticationErrorCode)[keyof typeof AuthenticationErrorCode];
export declare const authenticationResultSchema: z.ZodObject<{
    verified: z.ZodBoolean;
    credential: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        credentialId: z.ZodString;
        publicKey: z.ZodString;
        counter: z.ZodNumber;
        transports: z.ZodOptional<z.ZodArray<z.ZodEnum<["usb", "ble", "nfc", "internal", "cable", "hybrid", "smart-card"]>, "many">>;
        createdAt: z.ZodDate;
        lastUsedAt: z.ZodNullable<z.ZodDate>;
        name: z.ZodString;
        userId: z.ZodString;
        deviceType: z.ZodOptional<z.ZodString>;
        backedUp: z.ZodOptional<z.ZodBoolean>;
        aaguid: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    }, {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    }>>;
    userId: z.ZodOptional<z.ZodString>;
    error: z.ZodOptional<z.ZodString>;
    errorCode: z.ZodOptional<z.ZodNativeEnum<{
        /** Challenge not found or expired */
        readonly CHALLENGE_NOT_FOUND: "CHALLENGE_NOT_FOUND";
        /** Challenge has expired */
        readonly CHALLENGE_EXPIRED: "CHALLENGE_EXPIRED";
        /** Credential not found */
        readonly CREDENTIAL_NOT_FOUND: "CREDENTIAL_NOT_FOUND";
        /** Verification failed */
        readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
        /** Counter rollback detected (potential cloned authenticator) */
        readonly COUNTER_ROLLBACK: "COUNTER_ROLLBACK";
        /** User has no credentials */
        readonly NO_CREDENTIALS: "NO_CREDENTIALS";
        /** Invalid response format */
        readonly INVALID_RESPONSE: "INVALID_RESPONSE";
        /** User not found */
        readonly USER_NOT_FOUND: "USER_NOT_FOUND";
    }>>;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    verified?: boolean;
    credential?: {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    };
    error?: string;
    errorCode?: "CHALLENGE_NOT_FOUND" | "CHALLENGE_EXPIRED" | "VERIFICATION_FAILED" | "INVALID_RESPONSE" | "USER_NOT_FOUND" | "CREDENTIAL_NOT_FOUND" | "COUNTER_ROLLBACK" | "NO_CREDENTIALS";
}, {
    userId?: string;
    verified?: boolean;
    credential?: {
        id?: string;
        credentialId?: string;
        publicKey?: string;
        counter?: number;
        transports?: ("ble" | "cable" | "hybrid" | "internal" | "nfc" | "smart-card" | "usb")[];
        createdAt?: Date;
        lastUsedAt?: Date;
        name?: string;
        userId?: string;
        deviceType?: string;
        backedUp?: boolean;
        aaguid?: string;
    };
    error?: string;
    errorCode?: "CHALLENGE_NOT_FOUND" | "CHALLENGE_EXPIRED" | "VERIFICATION_FAILED" | "INVALID_RESPONSE" | "USER_NOT_FOUND" | "CREDENTIAL_NOT_FOUND" | "COUNTER_ROLLBACK" | "NO_CREDENTIALS";
}>;
/**
 * Attestation conveyance preference
 * Note: simplewebauthn only supports 'none', 'direct', and 'enterprise'
 */
export type AttestationConveyance = 'none' | 'direct' | 'enterprise';
/**
 * User verification requirement
 */
export type UserVerification = 'required' | 'preferred' | 'discouraged';
/**
 * Authenticator attachment preference
 */
export type AuthenticatorAttachment = 'platform' | 'cross-platform';
/**
 * Resident key requirement
 */
export type ResidentKey = 'required' | 'preferred' | 'discouraged';
/**
 * WebAuthn service configuration
 */
export interface WebAuthnConfig {
    /** Relying Party name displayed to users during registration */
    rpName: string;
    /** Relying Party ID (domain), e.g., 'vorion.org' */
    rpId: string;
    /** Full origin URL, e.g., 'https://vorion.org' */
    origin: string | string[];
    /** Attestation conveyance preference */
    attestation: AttestationConveyance;
    /** User verification requirement */
    userVerification: UserVerification;
    /** Timeout for WebAuthn operations in milliseconds */
    timeout: number;
    /** Default authenticator attachment preference */
    authenticatorAttachment?: AuthenticatorAttachment;
    /** Resident key requirement */
    residentKey: ResidentKey;
    /** Challenge TTL in milliseconds */
    challengeTTL: number;
    /** Supported algorithm IDs (e.g., -7 for ES256, -257 for RS256) */
    supportedAlgorithms: number[];
}
export declare const webAuthnConfigSchema: z.ZodObject<{
    rpName: z.ZodString;
    rpId: z.ZodString;
    origin: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
    attestation: z.ZodEnum<["none", "direct", "enterprise"]>;
    userVerification: z.ZodEnum<["required", "preferred", "discouraged"]>;
    timeout: z.ZodNumber;
    authenticatorAttachment: z.ZodOptional<z.ZodEnum<["platform", "cross-platform"]>>;
    residentKey: z.ZodEnum<["required", "preferred", "discouraged"]>;
    challengeTTL: z.ZodNumber;
    supportedAlgorithms: z.ZodArray<z.ZodNumber, "many">;
}, "strip", z.ZodTypeAny, {
    rpName?: string;
    rpId?: string;
    origin?: string | string[];
    attestation?: "none" | "direct" | "enterprise";
    userVerification?: "required" | "preferred" | "discouraged";
    timeout?: number;
    authenticatorAttachment?: "platform" | "cross-platform";
    residentKey?: "required" | "preferred" | "discouraged";
    challengeTTL?: number;
    supportedAlgorithms?: number[];
}, {
    rpName?: string;
    rpId?: string;
    origin?: string | string[];
    attestation?: "none" | "direct" | "enterprise";
    userVerification?: "required" | "preferred" | "discouraged";
    timeout?: number;
    authenticatorAttachment?: "platform" | "cross-platform";
    residentKey?: "required" | "preferred" | "discouraged";
    challengeTTL?: number;
    supportedAlgorithms?: number[];
}>;
/**
 * Default WebAuthn configuration
 */
export declare const DEFAULT_WEBAUTHN_CONFIG: WebAuthnConfig;
/**
 * Input for listing credentials
 */
export interface ListCredentialsInput {
    /** User ID to list credentials for */
    userId: string;
    /** Pagination limit */
    limit?: number;
    /** Pagination offset */
    offset?: number;
}
export declare const listCredentialsInputSchema: z.ZodObject<{
    userId: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
    offset: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    userId?: string;
    limit?: number;
    offset?: number;
}, {
    userId?: string;
    limit?: number;
    offset?: number;
}>;
/**
 * Input for renaming a credential
 */
export interface RenameCredentialInput {
    /** User ID that owns the credential */
    userId: string;
    /** Credential ID to rename */
    credentialId: string;
    /** New name for the credential */
    name: string;
}
export declare const renameCredentialInputSchema: z.ZodObject<{
    userId: z.ZodString;
    credentialId: z.ZodString;
    name: z.ZodString;
}, "strip", z.ZodTypeAny, {
    credentialId?: string;
    name?: string;
    userId?: string;
}, {
    credentialId?: string;
    name?: string;
    userId?: string;
}>;
/**
 * Input for deleting a credential
 */
export interface DeleteCredentialInput {
    /** User ID that owns the credential */
    userId: string;
    /** Credential ID to delete */
    credentialId: string;
}
export declare const deleteCredentialInputSchema: z.ZodObject<{
    userId: z.ZodString;
    credentialId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    credentialId?: string;
    userId?: string;
}, {
    credentialId?: string;
    userId?: string;
}>;
/**
 * Audit event types for WebAuthn operations
 */
export declare const WebAuthnAuditEventType: {
    readonly REGISTRATION_OPTIONS_GENERATED: "webauthn.registration_options_generated";
    readonly REGISTRATION_COMPLETED: "webauthn.registration_completed";
    readonly REGISTRATION_FAILED: "webauthn.registration_failed";
    readonly AUTHENTICATION_OPTIONS_GENERATED: "webauthn.authentication_options_generated";
    readonly AUTHENTICATION_COMPLETED: "webauthn.authentication_completed";
    readonly AUTHENTICATION_FAILED: "webauthn.authentication_failed";
    readonly COUNTER_ROLLBACK_DETECTED: "webauthn.counter_rollback_detected";
    readonly CREDENTIAL_DELETED: "webauthn.credential_deleted";
    readonly CREDENTIAL_RENAMED: "webauthn.credential_renamed";
};
export type WebAuthnAuditEventType = (typeof WebAuthnAuditEventType)[keyof typeof WebAuthnAuditEventType];
/**
 * Challenge entry with metadata
 */
export interface ChallengeEntry {
    /** The challenge string */
    challenge: string;
    /** User ID associated with this challenge */
    userId: string;
    /** Type of operation (registration or authentication) */
    type: 'registration' | 'authentication';
    /** Expiration timestamp (Unix ms) */
    expiresAt: number;
    /** Creation timestamp */
    createdAt: Date;
}
export declare const challengeEntrySchema: z.ZodObject<{
    challenge: z.ZodString;
    userId: z.ZodString;
    type: z.ZodEnum<["registration", "authentication"]>;
    expiresAt: z.ZodNumber;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    type?: "registration" | "authentication";
    createdAt?: Date;
    userId?: string;
    challenge?: string;
    expiresAt?: number;
}, {
    type?: "registration" | "authentication";
    createdAt?: Date;
    userId?: string;
    challenge?: string;
    expiresAt?: number;
}>;
//# sourceMappingURL=types.d.ts.map