import * as i0 from '@angular/core';
import { Injector, NgZone, OnDestroy, OnInit, AfterViewInit, ElementRef, EmbeddedViewRef, ChangeDetectorRef, ModuleWithProviders, NgModuleFactory, InjectionToken } from '@angular/core';
import * as _abp_ng_components_extensible from '@abp/ng.components/extensible';
import { EntityActionContributorCallback, ToolbarActionContributorCallback, EntityPropContributorCallback, EditFormPropContributorCallback } from '@abp/ng.components/extensible';
import * as _volo_abp_commercial_ng_ui_config from '@volo/abp.commercial.ng.ui/config';
import { IdentitySecurityLogDto, eProfilePictureType, IdentitySecurityLogGetListInput, ProfilePictureService } from '@volo/abp.commercial.ng.ui/config';
import * as _volo_abp_ng_account_public_proxy from '@volo/abp.ng.account/public/proxy';
import { ProfileDto, ProfileService, ChangePasswordInput, AccountService as AccountService$1, VerifyAuthenticatorCodeDto, IdentityLinkUserService, LinkUserInput, Volo, AccountSessionService } from '@volo/abp.ng.account/public/proxy';
import * as i1 from '@abp/ng.core';
import { LoginParams, PagedResultDto, ConfigStateService, LazyLoadService, AuthService, SubscriptionService, ABP, ListService, AbpWindowService, TreeNode } from '@abp/ng.core';
import * as i2 from '@abp/ng.theme.shared';
import { ToasterService, ConfirmationService } from '@abp/ng.theme.shared';
import * as i3 from '@volo/abp.commercial.ng.ui';
import * as _angular_router from '@angular/router';
import { ActivatedRoute, Router, Params, Routes } from '@angular/router';
import * as i5 from '@ng-bootstrap/ng-bootstrap';
import * as _ngx_validate_core from '@ngx-validate/core';
import { Validation } from '@ngx-validate/core';
import * as i7 from '@abp/ng.components/page';
import * as _angular_forms from '@angular/forms';
import { FormBuilder, FormControl, FormGroup, UntypedFormGroup, UntypedFormBuilder, AbstractControl } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import * as i9 from '@volo/abp.ng.account/admin';
import Cropper from 'cropperjs/dist/cropper.esm.js';
import { HttpParameterCodec } from '@angular/common/http';

declare const enum eAccountComponents {
    AuthWrapper = "Account.AuthWrapper",
    Login = "Account.LoginComponent",
    LoginWithRecoveryCodeComponent = "Account.LoginWithRecoveryCodeComponent",
    Register = "Account.RegisterComponent",
    EmailConfirmation = "Account.EmailConfirmationComponent",
    ForgotPassword = "Account.ForgotPasswordComponent",
    ResetPassword = "Account.ResetPasswordComponent",
    ManageProfile = "Account.ManageProfileComponent",
    TenantBox = "Account.TenantBoxComponent",
    ChangePassword = "Account.ChangePasswordComponent",
    RefreshPassword = "Account.RefreshPasswordComponent",
    PersonalSettings = "Account.PersonalSettingsComponent",
    Logo = "Account.LogoComponent",
    MySecurityLogs = "Account.MySecurityLogs",
    ProfilePicture = "Account.ProfilePicture",
    LinkLogged = "Account.LinkLogged",
    SendSecurityCode = "Account.SendSecurityCode",
    Sessions = "Account.Sessions",
    ConfirmUser = "Account.ConfirmUser"
}

type AccountEntityActionContributors = Partial<{
    [eAccountComponents.MySecurityLogs]: EntityActionContributorCallback<IdentitySecurityLogDto>[];
}>;
type AccountToolbarActionContributors = Partial<{
    [eAccountComponents.MySecurityLogs]: ToolbarActionContributorCallback<IdentitySecurityLogDto[]>[];
}>;
type AccountEntityPropContributors = Partial<{
    [eAccountComponents.MySecurityLogs]: EntityPropContributorCallback<IdentitySecurityLogDto>[];
}>;
type AccountEditFormPropContributors = Partial<{
    [eAccountComponents.PersonalSettings]: EditFormPropContributorCallback<ProfileDto>[];
}>;
interface AccountConfigOptions {
    redirectUrl?: string;
    entityActionContributors?: AccountEntityActionContributors;
    toolbarActionContributors?: AccountToolbarActionContributors;
    entityPropContributors?: AccountEntityPropContributors;
    personelInfoEntityPropContributors?: AccountEditFormPropContributors;
    /**
     * @deprecated
     * Don't need to re-login to application after change personal settings. It'll refresh current user's state.
     */
    isPersonalSettingsChangedConfirmationActive?: boolean;
}

declare class AccountPublicRoutingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountPublicRoutingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AccountPublicRoutingModule, never, [typeof _angular_router.RouterModule], [typeof _angular_router.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AccountPublicRoutingModule>;
}

interface ConfirmEmailInput {
    userId: string;
    token: string;
}
interface ConfirmPhoneNumberInput {
    token: string;
    userId: string;
}
interface ProfilePictureInput {
    type: eProfilePictureType;
    imageContent: number[];
}
interface ProfilePictureSourceDto {
    type: eProfilePictureType;
    source?: string;
    fileContent: number[];
}
interface RegisterDto {
    userName: string;
    emailAddress: string;
    password: string;
    appName: string;
    returnUrl?: string;
    returnUrlHash?: string;
    captchaResponse?: string;
}
interface ResetPasswordDto {
    userId?: string;
    resetToken: string;
    password: string;
}
interface SendEmailConfirmationTokenDto {
    appName: string;
    email: string;
    userId: string;
    returnUrl?: string;
    returnUrlHash?: string;
}
interface SendPhoneNumberConfirmationTokenDto {
    phoneNumber: string;
    userId: string;
}
interface SendPasswordResetCodeDto {
    email: string;
    appName: string;
    returnUrl?: string;
    returnUrlHash?: string;
}
interface IFormFile {
    contentType: string;
    contentDisposition: string;
    headers: any;
    length: number;
    name: string;
    fileName: string;
}
interface GetTwoFactorProvidersInput {
    userId: string;
    token: string;
}
interface SendTwoFactorCodeInput {
    userId: string;
    provider: string;
    token: string;
}
interface RecoveryCodeData extends LoginParams {
    userId: string;
}
type AuthenticatorSteps = 'Authenticator' | 'VerifyTheAuthenticator' | 'RecoveryCodes';

declare class AccountService {
    private restService;
    apiName: string;
    confirmEmail: (input: ConfirmEmailInput) => Observable<void>;
    confirmPhoneNumber: (input: ConfirmPhoneNumberInput) => Observable<void>;
    getProfilePicture: (id: string) => Observable<ProfilePictureSourceDto>;
    getProfilePictureFile: (id: string) => Observable<any>;
    register: (input: RegisterDto) => Observable<any>;
    resetPassword: (input: ResetPasswordDto) => Observable<void>;
    sendEmailConfirmationToken: (input: SendEmailConfirmationTokenDto) => Observable<void>;
    sendPasswordResetCode: (input: SendPasswordResetCodeDto) => Observable<void>;
    sendPhoneNumberConfirmationToken: (input: SendPhoneNumberConfirmationTokenDto) => Observable<void>;
    setProfilePicture: (input: ProfilePictureInput) => Observable<void>;
    uploadProfilePictureFile: (image: IFormFile) => Observable<any>;
    getMySecurityLogsByInput(params?: Partial<IdentitySecurityLogGetListInput>): Observable<PagedResultDto<IdentitySecurityLogDto>>;
    recaptchaByCaptchaResponse: (captchaResponse: string) => Observable<void>;
    getTwoFactorProviders: (input: GetTwoFactorProvidersInput) => Observable<string[]>;
    sendTwoFactorCode: (input: SendTwoFactorCodeInput) => Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
}

interface ManageProfileState {
    profile: ProfileDto;
    hideEmailVerificationBtn: boolean;
}
declare class ManageProfileStateService {
    private readonly store;
    get createStateStream(): <Slice>(selector: (state: ManageProfileState) => Slice, compareFn?: (s1: Slice, s2: Slice) => boolean) => Observable<Slice>;
    getProfile$(): Observable<ProfileDto>;
    getProfile(): ProfileDto;
    setProfile(profile: ProfileDto): void;
    setHideEmailVerificationBtn(hideEmailVerificationBtn: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ManageProfileStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ManageProfileStateService>;
}

declare abstract class RecaptchaPageStrategy {
    abstract action: string;
    abstract settingKey: string;
    protected configState: ConfigStateService;
    targetElement: HTMLElement;
    isEnabled: boolean;
    constructor(configState: ConfigStateService, targetElement: HTMLElement);
    protected setIsEnabled(): void;
}
declare class RecaptchaLoginStrategy extends RecaptchaPageStrategy {
    action: string;
    settingKey: string;
    constructor(configState: ConfigStateService, targetElement: HTMLElement);
}
declare class RecaptchaRegisterStrategy extends RecaptchaPageStrategy {
    action: string;
    settingKey: string;
    constructor(configState: ConfigStateService, targetElement: HTMLElement);
}
declare const RECAPTCHA_STRATEGY: {
    Login(configState: ConfigStateService, targetElement: HTMLElement): RecaptchaLoginStrategy;
    Register(configState: ConfigStateService, targetElement: HTMLElement): RecaptchaRegisterStrategy;
};
declare abstract class RecaptchaStrategy {
    protected abstract scriptPath: string;
    abstract getVerificationToken(): Observable<string>;
    protected injector: Injector;
    protected lazyLoadService: LazyLoadService;
    protected configState: ConfigStateService;
    protected insertedElement: ConfigStateService;
    protected get cultureName(): string;
    protected get siteKey(): string;
    protected get verifyBaseUrl(): string;
    constructor(injector: Injector);
    appendScript(): void;
    destroy(): void;
    reset(): void;
}
declare class RecaptchaV2Strategy extends RecaptchaStrategy {
    targetElement: HTMLElement;
    zone: NgZone;
    scriptPath: string;
    protected token: BehaviorSubject<string>;
    document: Document;
    constructor(injector: Injector, targetElement: HTMLElement);
    appendScript(): void;
    reset(): void;
    getVerificationToken(): Observable<string>;
}
declare class RecaptchaV3Strategy extends RecaptchaStrategy {
    action: string;
    scriptPath: string;
    document: Document;
    constructor(injector: Injector, action: string);
    appendScript(): void;
    getVerificationToken(): Observable<string>;
    destroy(): void;
}

declare class RecaptchaService implements OnDestroy {
    protected injector: Injector;
    protected configState: ConfigStateService;
    protected accountService: AccountService;
    protected pageStrategy: RecaptchaPageStrategy;
    protected strategy: RecaptchaStrategy;
    get isEnabled(): boolean;
    protected get reCaptchaVersion(): string;
    setStrategy(strategy: RecaptchaPageStrategy): void;
    protected init(): void;
    validate(): Observable<any>;
    getVerificationToken(): Observable<string>;
    ngOnDestroy(): void;
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecaptchaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecaptchaService>;
}

interface SecurityCodeData extends LoginParams {
    userId: string;
    twoFactorToken: string;
}
declare class SecurityCodeService {
    private injector;
    private toaster;
    private authService;
    data: SecurityCodeData;
    private pipeToLogin?;
    constructor();
    login(twoFactor: {
        provider: string;
        code: string;
    }): rxjs.Observable<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityCodeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityCodeService>;
}

declare class UrlComponentEncoder implements HttpParameterCodec {
    encodeKey(key: string): string;
    encodeValue(value: string): string;
    decodeKey(key: string): string;
    decodeValue(value: string): string;
}

declare class ChangePasswordService {
    protected readonly manageProfileState: ManageProfileStateService;
    protected readonly fb: FormBuilder;
    protected readonly toasterService: ToasterService;
    protected readonly activatedRoute: ActivatedRoute;
    protected readonly router: Router;
    protected readonly profileService: ProfileService;
    protected readonly authService: AuthService;
    protected readonly toasterSuccessOption: {
        message: string;
        title: string;
        options: {
            life: number;
        };
    };
    private legacyInjector;
    readonly PASSWORD_FIELDS: string[];
    private getQueryParams;
    readonly MapErrorsFnFactory: () => Validation.MapErrorsFn;
    get hasPassword(): boolean;
    private get returnUrl();
    buildForm(hideCurrentPassword?: boolean): _angular_forms.FormGroup<{
        currentPassword: _angular_forms.FormControl<string>;
        newPassword: _angular_forms.FormControl<string>;
        repeatNewPassword: _angular_forms.FormControl<string>;
    }>;
    changePassword(formValue: ChangePasswordInput): Observable<any>;
    changePasswordAndLogin(formValue: ChangePasswordInput): Observable<i1.AbpAuthResponse>;
    redirectToReturnUrl(): Observable<boolean>;
    showSuccessMessage(): void;
    showErrorMessage(err: {
        error?: {
            error?: {
                message: string;
            };
        };
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChangePasswordService>;
}

declare class TwoFactorTabService {
    protected readonly accountService: AccountService$1;
    protected readonly profileService: ProfileService;
    get isTwoFactorEnabled$(): Observable<boolean>;
    setTwoFactorStatus(status: boolean): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoFactorTabService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwoFactorTabService>;
}

interface TenantIdResponse {
    success: boolean;
    tenantId: string;
    name: string;
}

interface ConfirmUserParams {
    userId: string;
    email: Partial<{
        confirmed: boolean;
        showButton: boolean;
        requireSetting: boolean;
        address: string;
    }>;
    phone: Partial<{
        confirmed: boolean;
        requireSetting: boolean;
        number?: string;
    }>;
}

declare class RecoveryCodeService {
    private readonly pipeToLogin?;
    protected readonly injector: Injector;
    protected readonly authService: AuthService;
    protected readonly toaster: ToasterService;
    data: i0.WritableSignal<RecoveryCodeData>;
    hasData: i0.Signal<boolean>;
    login(recoveryCode: string): rxjs.Observable<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecoveryCodeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecoveryCodeService>;
}

interface ProgressBarStats {
    bgColor: string;
    text?: string;
    width: number;
}

interface RegexRequirementsModel {
    minLengthRegex: RegExp;
    numberRegex: RegExp;
    lowercaseRegex: RegExp;
    uppercaseRegex: RegExp;
    specialCharacterRegex: RegExp;
}
declare class PasswordComplexityIndicatorService {
    colors: string[];
    texts: string[];
    requirements: RegexRequirementsModel;
    validatePassword(password: string): ProgressBarStats;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordComplexityIndicatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PasswordComplexityIndicatorService>;
}

declare class AuthenticatorAppService {
    protected readonly accountService: AccountService$1;
    hasAuthenticator: i0.Signal<boolean>;
    authenticatorInfo: i0.Signal<_volo_abp_ng_account_public_proxy.AuthenticatorInfoDto>;
    resetAuthenticator(): Observable<void>;
    verifyAuthenticatorCode(code: string): Observable<VerifyAuthenticatorCodeDto>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticatorAppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticatorAppService>;
}

declare const REQUIRE_EMAIL_SETTING_KEY = "Abp.Identity.SignIn.RequireConfirmedEmail";
declare const REQUIRE_PHONE_SETTING_KEY = "Abp.Identity.SignIn.RequireConfirmedPhoneNumber";
declare class ConfirmUserService {
    #private;
    protected readonly destroy: Subject<void>;
    protected readonly router: Router;
    protected readonly configService: ConfigStateService;
    protected readonly accountService: AccountService$1;
    protected readonly toasterService: ToasterService;
    userId: i0.Signal<string>;
    email: i0.Signal<Partial<{
        confirmed: boolean;
        showButton: boolean;
        requireSetting: boolean;
        address: string;
    }>>;
    phone: i0.Signal<Partial<{
        confirmed: boolean;
        requireSetting: boolean;
        number?: string;
    }>>;
    protected isSettingTrueMap(): rxjs.OperatorFunction<unknown, boolean>;
    confirmationStateRequest$(): rxjs.Observable<_volo_abp_ng_account_public_proxy.IdentityUserConfirmationStateDto>;
    initialize(): void;
    update(updateFn: (prev: any) => Partial<ConfirmUserParams>): void;
    updateConfirmedState(emailConfirmed: boolean, phoneNumberConfirmed: boolean): void;
    validateUserId(): boolean;
    sendEmailConfirmation(): void;
    sendPhoneConfirmation(phoneNumber: string): void;
    verifyPhoneCode(token: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmUserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmUserService>;
}

declare class TwoFactorTabComponent {
    protected readonly fb: FormBuilder;
    protected readonly twoFactorTabService: TwoFactorTabService;
    readonly form: _angular_forms.FormGroup<{
        isTwoFactorEnabled: _angular_forms.FormControl<boolean>;
    }>;
    isLoaded: i0.WritableSignal<boolean>;
    protected isTwoFactorEnabled(): void;
    protected trackTwoFactorStatus(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoFactorTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwoFactorTabComponent, "abp-two-factor-tab", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsVerifyButtonComponent {
    readonly buttonLabel: i0.InputSignal<string>;
    readonly verifiedLabel: i0.InputSignal<string>;
    readonly verified: i0.InputSignal<boolean>;
    readonly edited: i0.InputSignal<boolean>;
    readonly editedLabel: i0.InputSignal<string>;
    readonly editedTooltip: i0.InputSignal<string>;
    readonly btnClick: i0.OutputEmitterRef<void>;
    onBtnClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsVerifyButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsVerifyButtonComponent, "abp-personal-settings-verify-button", never, { "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "verifiedLabel": { "alias": "verifiedLabel"; "required": false; "isSignal": true; }; "verified": { "alias": "verified"; "required": false; "isSignal": true; }; "edited": { "alias": "edited"; "required": false; "isSignal": true; }; "editedLabel": { "alias": "editedLabel"; "required": false; "isSignal": true; }; "editedTooltip": { "alias": "editedTooltip"; "required": false; "isSignal": true; }; }, { "btnClick": "btnClick"; }, never, never, true, never>;
}

interface ChangePasswordFormModel {
    currentPassword: FormControl<string>;
    newPassword: FormControl<string>;
    repeatNewPassword: FormControl<string>;
}

declare class ChangePasswordComponent implements OnInit {
    #private;
    private readonly service;
    protected readonly passwordComplexityService: PasswordComplexityIndicatorService;
    protected readonly subscription: SubscriptionService;
    form: FormGroup<ChangePasswordFormModel>;
    inProgress: boolean;
    progressBar: ProgressBarStats;
    hideCurrentPassword: boolean;
    showCurrentPassword: boolean;
    showNewPassword: boolean;
    showConfirmPassword: boolean;
    mapErrorsFn: _ngx_validate_core.Validation.MapErrorsFn;
    ngOnInit(): void;
    onSuccess(): void;
    onSubmit(): void;
    get newPassword(): string;
    validatePassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChangePasswordComponent, "abp-change-password-form", ["abpChangePasswordForm"], {}, {}, never, never, true, never>;
}

declare class RefreshPasswordComponent implements OnInit {
    private readonly passwordComplexityService;
    private readonly service;
    protected readonly subscription: SubscriptionService;
    form: FormGroup<ChangePasswordFormModel>;
    progressBar: ProgressBarStats;
    showCurrentPassword: boolean;
    showNewPassword: boolean;
    showConfirmPassword: boolean;
    mapErrorsFn: _ngx_validate_core.Validation.MapErrorsFn;
    ngOnInit(): void;
    onSuccess(): void;
    onSubmit(): void;
    get newPassword(): string;
    validatePassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshPasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefreshPasswordComponent, "abp-refresh-password-form", ["abpRefreshPasswordForm"], {}, {}, never, never, true, never>;
}

interface EmailConfirmationInput {
    confirmationToken: string;
    userId: string;
}
declare class EmailConfirmationComponent implements OnInit, OnDestroy {
    private multiTenancy;
    private accountService;
    private route;
    confirmed: boolean;
    notValid: boolean;
    private resetTenantBox;
    ngOnInit(): void;
    ngOnDestroy(): void;
    confirmation(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmailConfirmationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmailConfirmationComponent, "abp-email-confirmation", never, {}, {}, never, never, true, never>;
}

declare class ForgotPasswordComponent {
    private fb;
    private accountService;
    form: UntypedFormGroup;
    inProgress: boolean;
    isEmailSent: boolean;
    constructor();
    onSubmit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForgotPasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ForgotPasswordComponent, "abp-forgot-password", never, {}, {}, never, never, true, never>;
}

declare class LinkLoggedComponent implements OnInit {
    private injector;
    private router;
    private route;
    private identityLinkUserService;
    tenantAndUserName: string;
    get linkUser(): {
        linkUserId: any;
        linkTenantId: any;
        linkUserName: any;
        linkTenantName: any;
    };
    ngOnInit(): void;
    protected init(): void;
    protected navigateToLogin(): void;
    navigateToMainPage(queryParams?: Params): void;
    navigateToMainPageForLinkLogin(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkLoggedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkLoggedComponent, "abp-link-logged", never, {}, {}, never, never, true, never>;
}

declare class LoginComponent implements OnInit, AfterViewInit {
    protected readonly injector: Injector;
    protected readonly fb: FormBuilder;
    protected readonly toasterService: ToasterService;
    protected readonly authService: AuthService;
    protected readonly configState: ConfigStateService;
    protected readonly route: ActivatedRoute;
    protected readonly router: Router;
    protected readonly identityLinkUserService: IdentityLinkUserService;
    protected readonly recaptchaService: RecaptchaService;
    protected readonly securityCodeService: SecurityCodeService;
    protected readonly recoveryCodeService: RecoveryCodeService;
    protected readonly confirmUserService: ConfirmUserService;
    readonly recaptchaRef: i0.Signal<ElementRef<HTMLDivElement>>;
    form: _angular_forms.FormGroup<{
        username: _angular_forms.FormControl<string>;
        password: _angular_forms.FormControl<string>;
        rememberMe: _angular_forms.FormControl<boolean>;
    }>;
    inProgress: boolean;
    isSelfRegistrationEnabled: boolean;
    authWrapperKey: eAccountComponents;
    linkUser: LinkUserInput;
    showPassword: boolean;
    capsLock: boolean;
    protected init(): void;
    protected buildForm(): _angular_forms.FormGroup<{
        username: _angular_forms.FormControl<string>;
        password: _angular_forms.FormControl<string>;
        rememberMe: _angular_forms.FormControl<boolean>;
    }>;
    protected setLinkUserParams(): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onSubmit(): void;
    private checkRecaptcha;
    private switchToLinkUser;
    private handleLoginError;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "abp-login", never, {}, {}, never, never, true, never>;
}

declare class ManageProfileComponent {
    private tabsService;
    private configState;
    protected profileService: ProfileService;
    protected manageProfileState: ManageProfileStateService;
    protected readonly subscriptionService: SubscriptionService;
    firstTab: ABP.Tab;
    selected: ABP.Tab;
    isProfileLoaded: boolean;
    tabs$: rxjs.Observable<i1.TreeNode<Omit<ABP.Tab, "parentName">>[]>;
    get isTwoFactorEnabled(): boolean;
    protected setProfile(profile: ProfileDto): void;
    protected patchTwoFactorTab(canEnableTwoFactor: boolean): void;
    protected init(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ManageProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ManageProfileComponent, "abp-manage-profile", never, {}, {}, never, never, true, never>;
}

declare class MySecurityLogsComponent implements OnInit {
    protected readonly service: AccountService$1;
    readonly list: ListService<any>;
    data: PagedResultDto<Volo.Abp.Identity.IdentitySecurityLogDto>;
    filter: Partial<Volo.Abp.Identity.GetIdentitySecurityLogListInput>;
    ngOnInit(): void;
    private hookToQuery;
    static ɵfac: i0.ɵɵFactoryDeclaration<MySecurityLogsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MySecurityLogsComponent, "abp-my-security-logs", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsComponent {
    #private;
    protected readonly toasterService: ToasterService;
    protected readonly subscription: SubscriptionService;
    protected readonly manageProfileState: ManageProfileStateService;
    protected readonly profileService: ProfileService;
    protected readonly configState: ConfigStateService;
    protected readonly authService: AuthService;
    storedProfile: ProfileDto;
    profile$: Observable<ProfileDto>;
    modalBusy: boolean;
    modalRef: EmbeddedViewRef<any>;
    form: FormGroup<any>;
    token: string;
    isEmailUpdateEnabled: boolean;
    isUserNameUpdateEnabled: boolean;
    buildForm: (profile: ProfileDto) => void;
    constructor();
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsComponent, "abp-personal-settings-form", never, {}, {}, never, never, true, never>;
}

declare class ProfilePictureComponent implements OnInit {
    protected readonly cdRef: ChangeDetectorRef;
    protected readonly confirmation: ConfirmationService;
    protected readonly profilePictureService: ProfilePictureService;
    protected readonly configState: ConfigStateService;
    protected readonly toasterService: ToasterService;
    protected readonly profilePicture$: rxjs.BehaviorSubject<_volo_abp_commercial_ng_ui_config.ProfilePictureImage>;
    private document;
    readonly uploadFileRef: i0.Signal<ElementRef<any>>;
    readonly selectedImgRef: i0.Signal<ElementRef<any>>;
    readonly selectedImagePreviews: i0.Signal<readonly ElementRef<any>[]>;
    profileLoaded: boolean;
    inProgress: boolean;
    profilePictureType: eProfilePictureType;
    selectedImage: any;
    cropper: Cropper;
    get currentUserId(): string;
    private toBase64;
    ngOnInit(): void;
    getProfilePhoto(): void;
    submit(): void;
    onSelectImage(file: File): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfilePictureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProfilePictureComponent, "abp-profile-picture", never, {}, {}, never, never, true, never>;
}

interface RegisterFormModel {
    username: FormControl<string>;
    password: FormControl<string>;
    email: FormControl<string>;
}

declare class RegisterComponent implements OnInit, AfterViewInit {
    protected injector: Injector;
    protected fb: FormBuilder;
    protected accountService: AccountService;
    protected toasterService: ToasterService;
    protected configState: ConfigStateService;
    protected authService: AuthService;
    protected recaptchaService: RecaptchaService;
    protected passwordComplexityService: PasswordComplexityIndicatorService;
    readonly recaptchaRef: i0.Signal<ElementRef<HTMLDivElement>>;
    form: FormGroup<RegisterFormModel>;
    inProgress: boolean;
    isSelfRegistrationEnabled: boolean;
    showPassword: boolean;
    capsLock: boolean;
    progressBar: ProgressBarStats;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onSubmit(): void;
    get password(): string;
    validatePassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterComponent, "abp-register", never, {}, {}, never, never, true, never>;
}

declare class ResetPasswordComponent implements OnInit {
    inProgress: boolean;
    isPasswordReset: boolean;
    form: UntypedFormGroup;
    progressBar: ProgressBarStats;
    private readonly passwordComplexityService;
    private fb;
    private accountService;
    private route;
    private router;
    private injector;
    mapErrorsFn: Validation.MapErrorsFn;
    ngOnInit(): void;
    onSubmit(): void;
    get password(): string;
    validatePassword(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetPasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResetPasswordComponent, "abp-reset-password", never, {}, {}, never, never, true, never>;
}

declare class SendSecurityCodeComponent implements OnInit, OnDestroy {
    protected service: SecurityCodeService;
    protected accountService: AccountService;
    protected fb: UntypedFormBuilder;
    providers: string[];
    selectedProvider: string;
    loading: boolean;
    showCodeForm: boolean;
    codeForm: _angular_forms.UntypedFormGroup;
    ngOnInit(): void;
    ngOnDestroy(): void;
    sendTwoFactorCode(): void;
    login(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SendSecurityCodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SendSecurityCodeComponent, "abp-send-security-code", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsHalfRowComponent {
    private formProp;
    displayName: string;
    name: string;
    id: string;
    formGroup: UntypedFormGroup;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsHalfRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsHalfRowComponent, "abp-personal-settings-half-row", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsEmailComponent {
    private formProp;
    private propData;
    private formGroupDirective;
    private manageProfileState;
    private toasterService;
    private accountService;
    private configState;
    private environmentService;
    protected readonly subscriptionService: SubscriptionService;
    displayName: string;
    name: string;
    id: string;
    initialValue: string;
    isValueChanged$: Observable<boolean>;
    isVerified: boolean;
    isReadonly$: Observable<boolean>;
    showEmailVerificationBtn$: Observable<boolean>;
    private formGroup;
    private formControl;
    constructor();
    get userId(): string;
    sendEmailVerificationToken(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsEmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsEmailComponent, "abp-personal-settings-email", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsPhoneNumberComponent {
    private formProp;
    private propData;
    private formGroupDirective;
    private configState;
    private accountService;
    private toasterService;
    private manageProfileState;
    private cdr;
    displayName: string;
    name: string;
    id: string;
    isEnablePhoneNumberConfirmation: boolean;
    initialValue: string;
    isValueChanged$: Observable<boolean>;
    isVerified: boolean;
    modalVisible: boolean;
    token: string;
    private formGroup;
    formControl: AbstractControl;
    modalBusy: boolean;
    constructor();
    getIsEnablePhoneNumberConfirmation(): boolean;
    get userId(): string;
    initPhoneNumberConfirmation: () => void;
    openModal: () => void;
    removeModal: () => void;
    setPhoneNumberAsConfirmed: () => void;
    confirmPhoneNumber(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsPhoneNumberComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsPhoneNumberComponent, "abp-personal-settings-phone-number", never, {}, {}, never, never, true, never>;
}

declare class PersonalSettingsTimerZoneComponent {
    protected readonly profileService: ProfileService;
    protected readonly formProp: _abp_ng_components_extensible.FormProp<any>;
    timeZones$: Observable<Volo.Abp.NameValue[]>;
    get name(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalSettingsTimerZoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalSettingsTimerZoneComponent, "abp-personal-settings-time-zone", never, {}, {}, never, never, true, never>;
}

declare class PasswordComplexityIndicatorComponent {
    readonly progressBar: i0.InputSignal<ProgressBarStats>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordComplexityIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordComplexityIndicatorComponent, "abp-password-complexity-indicator", never, { "progressBar": { "alias": "progressBar"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AccountPublicModule {
    static forChild(options: AccountConfigOptions): ModuleWithProviders<AccountPublicModule>;
    /**
     * @deprecated `AccountPublicModule.forLazy()` is deprecated. You can use `createRoutes` **function** instead.
     */
    static forLazy(options?: AccountConfigOptions): NgModuleFactory<AccountPublicModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountPublicModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AccountPublicModule, never, [typeof i1.CoreModule, typeof i2.PasswordComponent, typeof i3.CommercialUiModule, typeof AccountPublicRoutingModule, typeof i2.ThemeSharedModule, typeof i5.NgbDropdownModule, typeof _ngx_validate_core.NgxValidateCoreModule, typeof i5.NgbPopoverModule, typeof i5.NgbDatepickerModule, typeof i5.NgbTooltipModule, typeof i7.PageModule, typeof i1.ShowPasswordDirective, typeof i1.TrackCapsLockDirective, typeof TwoFactorTabComponent, typeof i9.TimeZoneSettingComponent, typeof i3.DatetimePickerComponent, typeof PersonalSettingsVerifyButtonComponent, typeof ChangePasswordComponent, typeof RefreshPasswordComponent, typeof EmailConfirmationComponent, typeof ForgotPasswordComponent, typeof LinkLoggedComponent, typeof LoginComponent, typeof ManageProfileComponent, typeof MySecurityLogsComponent, typeof PersonalSettingsComponent, typeof ProfilePictureComponent, typeof RegisterComponent, typeof ResetPasswordComponent, typeof SendSecurityCodeComponent, typeof PersonalSettingsHalfRowComponent, typeof PersonalSettingsEmailComponent, typeof PersonalSettingsPhoneNumberComponent, typeof PersonalSettingsTimerZoneComponent, typeof PasswordComplexityIndicatorComponent], [typeof ChangePasswordComponent, typeof RefreshPasswordComponent, typeof EmailConfirmationComponent, typeof ForgotPasswordComponent, typeof LinkLoggedComponent, typeof LoginComponent, typeof ManageProfileComponent, typeof MySecurityLogsComponent, typeof PersonalSettingsComponent, typeof ProfilePictureComponent, typeof RegisterComponent, typeof ResetPasswordComponent, typeof SendSecurityCodeComponent, typeof PersonalSettingsHalfRowComponent, typeof PersonalSettingsEmailComponent, typeof PersonalSettingsPhoneNumberComponent, typeof PersonalSettingsTimerZoneComponent, typeof PasswordComplexityIndicatorComponent, typeof PersonalSettingsVerifyButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AccountPublicModule>;
}

declare function createRoutes(config?: AccountConfigOptions): Routes;

declare class LoginWithRecoveryCodeComponent {
    protected readonly fb: FormBuilder;
    protected readonly recoveryCodeService: RecoveryCodeService;
    protected loading: boolean;
    protected readonly form: _angular_forms.FormGroup<{
        recoveryCode: _angular_forms.FormControl<null>;
    }>;
    login(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginWithRecoveryCodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginWithRecoveryCodeComponent, "abp-login-with-recovery-code", never, {}, {}, never, never, true, never>;
}

declare class QrCodeComponent {
    readonly qrData: i0.InputSignal<string>;
    readonly width: i0.InputSignal<number>;
    readonly errorCorrectionLevel: i0.InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<QrCodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QrCodeComponent, "abp-qr-code", never, { "qrData": { "alias": "qrData"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "errorCorrectionLevel": { "alias": "errorCorrectionLevel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AuthenticatorAppComponent {
    protected readonly authenticatorAppService: AuthenticatorAppService;
    protected readonly windowService: AbpWindowService;
    protected readonly toasterService: ToasterService;
    protected readonly confirmationService: ConfirmationService;
    activeStep: AuthenticatorSteps;
    verifyCode: string;
    isVerifiedAuthenticatorCode: i0.WritableSignal<boolean>;
    hasAuthenticator: i0.Signal<boolean>;
    authenticatorInfo: i0.Signal<_volo_abp_ng_account_public_proxy.AuthenticatorInfoDto>;
    recoveryCodeList: i0.WritableSignal<string[]>;
    hasRecoveryCodes: i0.Signal<boolean>;
    copyToClipboard(text: string): void;
    verifyQrCode(): void;
    printRecoverCodes(): void;
    recoveryCodeOk(): void;
    copySharedKey(): void;
    copyRecoveryCodes(): void;
    resetAuthenticator(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticatorAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthenticatorAppComponent, "abp-authenticator-app", never, {}, {}, never, never, true, never>;
}

declare class AccountSessionDetailComponent implements OnInit {
    protected readonly service: AccountSessionService;
    modalOptions: {
        size: string;
    };
    isModalVisible: i0.ModelSignal<boolean>;
    sessionId: i0.InputSignal<string>;
    sessionInfo: i0.WritableSignal<_volo_abp_ng_account_public_proxy.IdentitySessionDto>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountSessionDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountSessionDetailComponent, "abp-account-session-detail", never, { "isModalVisible": { "alias": "isModalVisible"; "required": false; "isSignal": true; }; "sessionId": { "alias": "sessionId"; "required": true; "isSignal": true; }; }, { "isModalVisible": "isModalVisibleChange"; }, never, never, true, never>;
}

declare class AccountSessionsComponent implements OnInit {
    protected readonly list: ListService<any>;
    protected readonly service: AccountSessionService;
    protected readonly confirmationService: ConfirmationService;
    protected readonly authService: AuthService;
    protected readonly configStateService: ConfigStateService;
    data: i0.WritableSignal<PagedResultDto<_volo_abp_ng_account_public_proxy.IdentitySessionDto>>;
    sessionId: i0.WritableSignal<string>;
    visibleSessionDetailModal: i0.WritableSignal<boolean>;
    protected hookToQuery(): void;
    ngOnInit(): void;
    showDetail(row: Volo.Abp.Identity.IdentitySessionDto): void;
    revokeSession(row: Volo.Abp.Identity.IdentitySessionDto): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountSessionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountSessionsComponent, "abp-account-sessions", never, {}, {}, never, never, true, never>;
}

declare class ConfirmUserComponent {
    protected readonly confirmUserService: ConfirmUserService;
    protected readonly fb: FormBuilder;
    email: i0.Signal<Partial<{
        confirmed: boolean;
        showButton: boolean;
        requireSetting: boolean;
        address: string;
    }>>;
    phone: i0.Signal<Partial<{
        confirmed: boolean;
        requireSetting: boolean;
        number?: string;
    }>>;
    phoneModalVisible: boolean;
    form: _angular_forms.FormGroup<{
        phoneNumber: _angular_forms.FormControl<string>;
    }>;
    phoneCodeForm: _angular_forms.FormGroup<{
        verificationCode: _angular_forms.FormControl<string>;
    }>;
    protected initialize(): void;
    constructor();
    sendEmailConfirmation(): void;
    sendPhoneConfirmation(): void;
    verifyPhoneCode(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmUserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmUserComponent, "abp-confirm-user", never, {}, {}, never, never, true, never>;
}

declare const enum eAccountRouteNames {
    Account = "AbpAccount::Menu:Account",
    Login = "AbpAccount::Login",
    Register = "AbpAccount::Register",
    ForgotPassword = "AbpAccount::ForgotPassword",
    ResetPassword = "AbpAccount::ResetPassword",
    ManageProfile = "AbpAccount::MyAccount"
}

declare const REQUIRES_TWO_FACTOR = "RequiresTwoFactor";
declare const SHOULD_CHANGE_PASSWORD_ON_NEXT_LOGIN = "ShouldChangePasswordOnNextLogin";
declare const PERIODICALLY_CHANGE_PASSWORD = "PeriodicallyChangePassword";
declare const REQUIRES_CONFIRM_USER = "RequiresConfirmUser";

/**
 * @deprecated Use `authenticationFlowGuard` *function* instead.
 */
declare class AuthenticationFlowGuard {
    private authService;
    canActivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationFlowGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationFlowGuard>;
}
declare const authenticationFlowGuard: () => boolean;

declare const confirmUserGuard: () => boolean;

/**
 * @deprecated Use `accountExtensionsResolver` *function* instead.
 */
declare class AccountExtensionsGuard {
    private readonly injector;
    canActivate(): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountExtensionsGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccountExtensionsGuard>;
}

/**
 * @deprecated Use `securityCodeGuard` *function* instead.
 */
declare class SecurityCodeGuard {
    private service;
    private router;
    canActivate(): true | _angular_router.UrlTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<SecurityCodeGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SecurityCodeGuard>;
}
declare const securityCodeGuard: () => true | _angular_router.UrlTree;

/**
 * @deprecated Use `recoveryCodeGuard` *function* instead.
 */
declare class RecoveryCodeGuard {
    protected readonly router: Router;
    protected readonly recoveryCodeService: RecoveryCodeService;
    canActivate(): true | _angular_router.UrlTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecoveryCodeGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecoveryCodeGuard>;
}
declare const recoveryCodeGuard: () => true | _angular_router.UrlTree;

declare const ACCOUNT_CONFIG_OPTIONS: InjectionToken<AccountConfigOptions>;

/**
 * @deprecated
 * Don't need to re-login to application after change personal settings. It'll refresh current user's state.
 */
declare const RE_LOGIN_CONFIRMATION_TOKEN: InjectionToken<boolean>;

declare function getRedirectUrl(injector: Injector): string;

declare function accountOptionsFactory(options: AccountConfigOptions): any;

declare class ManageProfileResolver {
    private manageProfileTabs;
    private replaceableComponentsService;
    resolve(): rxjs.Observable<TreeNode<Omit<ABP.Tab, "parentName">>[]>;
    private addComponentsToTabs;
    static ɵfac: i0.ɵɵFactoryDeclaration<ManageProfileResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ManageProfileResolver>;
}

export { ACCOUNT_CONFIG_OPTIONS, AccountExtensionsGuard, AccountPublicModule, AccountService, AccountSessionDetailComponent, AccountSessionsComponent, AuthenticationFlowGuard, AuthenticatorAppComponent, AuthenticatorAppService, ChangePasswordComponent, ChangePasswordService, ConfirmUserComponent, ConfirmUserService, EmailConfirmationComponent, ForgotPasswordComponent, LinkLoggedComponent, LoginComponent, LoginWithRecoveryCodeComponent, ManageProfileComponent, ManageProfileResolver, ManageProfileStateService, MySecurityLogsComponent, PERIODICALLY_CHANGE_PASSWORD, PasswordComplexityIndicatorComponent, PasswordComplexityIndicatorService, PersonalSettingsComponent, PersonalSettingsEmailComponent, PersonalSettingsHalfRowComponent, PersonalSettingsPhoneNumberComponent, PersonalSettingsTimerZoneComponent, PersonalSettingsVerifyButtonComponent, ProfilePictureComponent, QrCodeComponent, RECAPTCHA_STRATEGY, REQUIRES_CONFIRM_USER, REQUIRES_TWO_FACTOR, REQUIRE_EMAIL_SETTING_KEY, REQUIRE_PHONE_SETTING_KEY, RE_LOGIN_CONFIRMATION_TOKEN, RecaptchaLoginStrategy, RecaptchaPageStrategy, RecaptchaRegisterStrategy, RecaptchaService, RecaptchaStrategy, RecaptchaV2Strategy, RecaptchaV3Strategy, RecoveryCodeGuard, RecoveryCodeService, RefreshPasswordComponent, RegisterComponent, ResetPasswordComponent, SHOULD_CHANGE_PASSWORD_ON_NEXT_LOGIN, SecurityCodeGuard, SecurityCodeService, SendSecurityCodeComponent, TwoFactorTabComponent, TwoFactorTabService, UrlComponentEncoder, accountOptionsFactory, authenticationFlowGuard, confirmUserGuard, createRoutes, eAccountComponents, eAccountRouteNames, getRedirectUrl, recoveryCodeGuard, securityCodeGuard };
export type { AccountConfigOptions, AccountEditFormPropContributors, AccountEntityActionContributors, AccountEntityPropContributors, AccountToolbarActionContributors, AuthenticatorSteps, ConfirmEmailInput, ConfirmPhoneNumberInput, ConfirmUserParams, EmailConfirmationInput, GetTwoFactorProvidersInput, IFormFile, ManageProfileState, ProfilePictureInput, ProfilePictureSourceDto, RecoveryCodeData, RegexRequirementsModel, RegisterDto, ResetPasswordDto, SecurityCodeData, SendEmailConfirmationTokenDto, SendPasswordResetCodeDto, SendPhoneNumberConfirmationTokenDto, SendTwoFactorCodeInput, TenantIdResponse };