import * as Soap from "@soapjs/soap";
export type AuthResult<TUser extends Soap.AuthUser = Soap.AuthUser> = Soap.AuthResult<TUser>;
export type AuthStrategy<TUser extends Soap.AuthUser = Soap.AuthUser, TContext extends Soap.HttpContext = Soap.HttpContext> = Soap.AuthStrategy<TUser, TContext>;
import { LocalStrategyConfig } from "./strategies/local/local.types";
import { OAuth2ProviderConfig } from "./strategies/oauth2/oauth2.types";
import { ApiKeyStrategyConfig } from "./strategies/api-key/api-key.types";
import { BasicStrategyConfig } from "./strategies/basic/basic.types";
import { JwtConfig } from "./strategies/jwt/jwt.types";
export type AuthCategories = "http" | "socket" | "grpc" | "webhook" | "edge" | "isa" | "event";
export interface SessionStore {
    getSession<T = SessionData>(sid: string, ...args: unknown[]): Promise<T | null>;
    setSession<T = SessionData>(sid: string, session: T, ...args: unknown[]): void | Promise<void>;
    destroySession(sid: string, ...args: unknown[]): void | Promise<void>;
    touchSession<T = SessionData>(sid: string, session: T, ...args: unknown[]): void | Promise<void>;
    getSessionIds(): Promise<string[]>;
}
export type SessionData = {
    [key: string]: any;
} | any;
export type SessionInfo<TData = any> = {
    sessionId: string;
    data: TData;
};
export interface SessionConfig {
    secret: string;
    resave?: boolean;
    saveUninitialized?: boolean;
    store?: SessionStore;
    sessionKey?: string;
    sessionHeader?: string;
    generateSessionId?: (...args: unknown[]) => string;
    createSessionData?: <T>(data?: unknown, context?: unknown) => T;
    embedSessionId?: (context: any, sessionId: string) => void;
    getSessionId(context: any): string | null;
    [key: string]: any;
}
export type Credentials = {
    id: string;
    hashedPassword: string;
    [key: string]: unknown;
};
export interface AuthResultConfig<TContext = unknown, TUser = unknown> {
    onSuccess?: (action: string, context: AuthSuccessContext<TUser, TContext>) => Promise<void> | void;
    onFailure?: (action: string, context: AuthFailureContext<TContext>) => Promise<void> | void;
}
export interface AuthThrottleConfig {
    incrementFailedAttempts?: (identifier: string, ...rest: unknown[]) => Promise<void>;
    resetFailedAttempts?: (identifier: string, ...rest: unknown[]) => Promise<void>;
    getFailedAttempts?: (identifier: string, ...rest: unknown[]) => Promise<number>;
    maxFailedAttempts?: number;
}
export interface BaseAuthStrategyConfig<TContext = unknown, TUser = unknown> extends AuthResultConfig<TContext, TUser> {
    mfa?: MfaConfig<TUser, TContext>;
    session?: SessionConfig;
    role?: RoleAuthorizationConfig<TUser>;
    rateLimit?: RateLimitConfig;
    throttle?: AuthThrottleConfig;
    lock?: AccountLockConfig<TContext>;
}
export interface MfaConfig<TUser = unknown, TContext = unknown> {
    extractMfaCode?: (context?: TContext) => string;
    sendMfaCode?: (user: TUser, context?: TContext) => Promise<boolean>;
    validateMfaCode?: (user: TUser, code: string) => Promise<boolean>;
    isMfaRequired?: (user: TUser) => boolean;
    generateMfaSecret?: (user: TUser) => Promise<string>;
    verifyMfaSetup?: (user: TUser, secret: string) => Promise<boolean>;
    disableMfa?: (user: TUser) => Promise<void>;
    generateBackupCodes?: (user: TUser) => Promise<string[]>;
    validateBackupCode?: (user: TUser, code: string) => Promise<boolean>;
    maxMfaAttempts?: number;
    lockMfaOnFailure?: (user: TUser) => Promise<void>;
    getMfaAttempts?: (user: TUser) => Promise<number>;
    resetMfaAttempts?: (user: TUser) => Promise<void>;
    incrementMfaAttempts?: (user: TUser) => Promise<void>;
}
export type PasswordType = "default" | "one-time" | "temporary";
export type NewPasswordOptions = {
    expiresIn?: string | number;
    type: PasswordType;
    additional?: Record<string, unknown>;
};
export type PasswordInfo = {
    type: PasswordType;
    expiresIn?: string | number;
    lastChangeDate?: Date;
};
export interface PasswordPolicyConfig {
    validatePassword?: (password: string, previousPassword?: string) => Promise<void>;
    getPasswordPasswordInfo?: (identifier: string) => Promise<PasswordInfo>;
    passwordExpirationDays?: number;
    generateResetToken?: (identifier: string) => Promise<string>;
    sendPasswordResetEmail?: (identifier: string, token: string) => Promise<void>;
    validatePasswordResetToken?: (token: string) => Promise<boolean>;
    updatePassword?: (identifier: string, newPassword: string, options?: NewPasswordOptions) => Promise<void>;
    generatePassword?: (identifier: string, options: NewPasswordOptions) => Promise<string>;
}
export interface UserConfig<TUser = unknown> {
    fetchUser: (payload: unknown) => Promise<TUser | null>;
    validateUser?: (payload: unknown) => Promise<any>;
}
export type CredentailsConfig<TContext = any> = CredentialsConfig<TContext>;
export interface CredentialsConfig<TContext = any> {
    extractCredentials: <TCredentials = {
        identifier: string;
        password: string;
        newPassword?: string;
    }>(context: TContext) => TCredentials;
    verifyCredentials: (identifier: string, password: string) => Promise<boolean>;
}
export interface CredentialAuthStrategyConfig<TContext = unknown, TUser = unknown> extends BaseAuthStrategyConfig<TContext, TUser> {
    passwordPolicy?: PasswordPolicyConfig;
    credentials?: CredentialsConfig<TContext>;
    jwt?: TokenAuthConfig<TContext>;
    user?: UserConfig<TUser>;
    allowGuest?: boolean;
    routes: {
        login: AuthRouteConfig;
        logout: AuthRouteConfig;
        resetPassword?: AuthRouteConfig;
        changePassword?: AuthRouteConfig;
        requestPasswordReset?: AuthRouteConfig;
    };
}
export type AuthRouteConfig = {
    path: string;
    method: string;
};
export interface TokenAuthConfig<TContext = unknown, TUser = unknown> {
    accessToken?: TokenConfig<TContext>;
    refreshToken?: RefreshTokenConfig<TContext, TUser>;
}
export interface TokenAuthStrategyConfig<TContext = unknown, TUser = unknown> extends BaseAuthStrategyConfig<TContext, TUser>, TokenAuthConfig<TContext, TUser> {
    user?: UserConfig<TUser>;
    routes: {
        login?: AuthRouteConfig;
        logout?: AuthRouteConfig;
        refresh?: AuthRouteConfig;
        [key: string]: AuthRouteConfig;
    };
}
export interface AccountLockConfig<TContext = unknown> {
    logFailedAttempt?: (account: any, context?: TContext) => Promise<void>;
    lockAccount: (account: any) => Promise<void>;
    removeAccountLock: (account: any) => Promise<void>;
    hasAccountLockExpired: (account: any) => Promise<boolean>;
    isAccountLocked: (account: any, context?: TContext) => Promise<boolean>;
    lockoutDuration?: number;
    notifyOnLockout?: (account: any) => Promise<void>;
}
export interface RateLimitConfig {
    checkRateLimit: (...args: unknown[]) => Promise<boolean>;
    incrementRequestCount?: (...args: unknown[]) => Promise<void>;
}
export interface RoleAuthorizationConfig<TUser = unknown> {
    authorizeByRoles?: (user: TUser, roles: string[]) => Promise<boolean>;
    roles?: string[];
}
export type AuthSuccessContext<TUser = unknown, TContext = unknown, TSessionData = unknown> = {
    user?: TUser;
    context?: TContext;
    session?: SessionInfo<TSessionData>;
    tokens?: Record<string, unknown>;
    identifier?: string;
    email?: string;
    additional?: Record<string, unknown>;
};
export type AuthFailureContext<TContext = unknown> = {
    error: Error;
    context?: TContext;
    identifier?: string;
    email?: string;
    additional?: Record<string, unknown>;
};
export interface SoapHttpAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
    local?: LocalStrategyConfig<TContext, TUser>;
    jwt?: JwtConfig<TContext, TUser>;
    oauth2?: {
        [provider: string]: OAuth2ProviderConfig<TContext, TUser>;
    };
    hybridOAuth2?: {
        [provider: string]: OAuth2ProviderConfig<TContext, TUser>;
    };
    apiKey?: ApiKeyStrategyConfig<TContext, TUser>;
    basic?: BasicStrategyConfig<TContext, TUser>;
    custom?: {
        [label: string]: Soap.AuthStrategy;
    };
}
export interface SoapSocketAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
    jwt?: JwtConfig<TContext, TUser>;
    apiKey?: ApiKeyStrategyConfig<TContext, TUser>;
    custom?: {
        [provider: string]: Soap.AuthStrategy;
    };
}
export interface SoapAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
    session?: SessionConfig;
    jwt?: TokenAuthConfig<TContext, TUser>;
    http?: SoapHttpAuthConfig<TContext, TUser>;
    socket?: SoapSocketAuthConfig<TContext, TUser>;
    logger?: Soap.Logger;
}
export interface CookieStorageOptions {
    cookieName: string;
    httpOnly: boolean;
    secure: boolean;
    sameSite?: "strict" | "lax" | "none";
    maxAge?: number;
}
export interface HeaderStorageOptions {
    headerName: string;
    scheme?: string;
    extractor: (scheme: string) => string | null;
}
export interface BodyStorageOptions {
    name: string;
    extractor: (name: string) => string | null;
}
export interface QueryStorageOptions {
    name: string;
    extractor: (name: string) => string | null;
}
export interface SessionStorageOptions {
    name: string;
    extractor: (name: string) => string | null;
}
export interface DatabaseOptions {
    extractor: (...args: unknown[]) => Promise<string | null>;
}
export interface StorageContext {
    storeInHeader?: (data: string, options?: HeaderStorageOptions) => Promise<void> | void;
    storeInCookie?: (data: string, options?: CookieStorageOptions) => Promise<void> | void;
    storeInSession?: (data: string, name?: string) => Promise<void> | void;
    storeInBody?: (data: string, name?: string) => Promise<void> | void;
    getFromHeader?: (options?: HeaderStorageOptions) => Promise<string | null> | string | null;
    getFromCookie?: (cookieName: string) => Promise<string | undefined> | string | undefined;
    getFromSession?: (name: string) => Promise<string | undefined> | string | undefined;
    getFromBodyField?: (name: string) => Promise<string | undefined> | string | undefined;
    removeFromCookie?: (cookieName: string) => Promise<void> | void;
    removeFromSession?: (name: string) => Promise<void> | void;
    encrypt?: (data: string) => Promise<string> | string;
    decrypt?: (data: string) => Promise<string> | string;
}
export interface TokenIssuerConfig<TContext = unknown> {
    secretKey: string;
    options: {
        expiresIn: string | number;
        audience?: string | string[];
        issuer?: string | string[];
        subject?: string;
        [option: string]: unknown;
    };
    buildPayload?: (user: any, context?: TContext) => Record<string, any>;
    generate?: (data: any, context?: TContext) => string;
}
export interface TokenVerifierConfig {
    options: {
        [option: string]: unknown;
    };
    verify?: (token: string) => Promise<any>;
}
export interface PersistenceMetadata {
    key?: string;
    name?: string;
    expiration?: number;
    expiresIn?: string | number;
    [key: string]: unknown;
}
export interface PersistenceConfig<T = any, TContext = any> {
    store?: (data: any, context?: TContext | null, metadata?: PersistenceMetadata, ...args: any[]) => Promise<void> | void;
    read?: (context?: TContext | null, key?: string, ...args: any[]) => Promise<T | null> | T | null;
    remove?: (context?: TContext | null, key?: string, ...args: any[]) => Promise<void> | void;
}
export interface ContextOperationConfig<TContext = any, TData = any> {
    embed?: (context: TContext, data: TData) => void;
    extract?: (context: TContext) => TData | null;
}
export interface TokenConfig<TContext = any, TUser = any> extends ContextOperationConfig<TContext, string> {
    rotation?: TokenRotationConfig<TContext, TUser>;
    issuer?: TokenIssuerConfig<TContext>;
    verifier?: TokenVerifierConfig;
    persistence?: PersistenceConfig<string, TContext>;
    additional?: Record<string, unknown>;
}
export interface RefreshTokenConfig<TContext = any, TUser = any> extends TokenConfig<TContext, TUser> {
    absoluteExpiry?: AbsoluteExpiryConfig;
}
export interface AbsoluteExpiryConfig {
    payloadField?: string;
    onExpiry?: "error" | "logout" | "ignore";
}
export interface TokenRotationConfig<TContext, TUser> {
    maxRotations?: number;
    getRotationCount?: (token: string, user: TUser, context: TContext) => Promise<number>;
    rotateToken?: (oldToken: string, user: TUser, context: TContext) => Promise<{
        newToken: string;
        newRotationCount?: number;
    }>;
    afterRotation?: (oldToken: string, newToken: string, user: TUser, context: TContext, rotationCount?: number) => Promise<void>;
    isLimitReached?: (rotationCount: number, maxRotations: number | undefined, user: TUser, context: TContext) => boolean;
}
export interface PKCEConfig<TContext> {
    challenge: {
        expiresIn?: number;
        generate?: (codeVerifier: string) => string;
        embed?: (context: TContext, challenge: string) => void;
        extract?: (context: TContext) => string | null;
        persistence?: PersistenceConfig<any, TContext>;
    };
    verifier: {
        expiresIn?: number;
        generate?: () => string;
        embed?: (context: TContext, codeVerifier: string) => void;
        extract?: (context: TContext) => string | null;
        persistence?: PersistenceConfig<any, TContext>;
    };
}