@getauthui/core 0.1.0

package/dist/authui.d.ts

@@ -0,0 +1,743 @@
+import { Client } from 'appwrite';
+import { CSSResult } from 'lit';
+import { LitElement } from 'lit';
+import { Models } from 'appwrite';
+import { nothing } from 'lit';
+import { TemplateResult } from 'lit';
+
+/**
+ * Single source of truth for the widget. Wraps the Appwrite Account service,
+ * tracks the signed-in user and broadcasts changes on `window` as `authui:change`.
+ */
+export declare class AuthStore {
+    private client;
+    private account;
+    private config;
+    private state;
+    private listeners;
+    private refreshPromise;
+    /** Configure the Appwrite client. Safe to call more than once; the last call wins. */
+    configure(config: AuthUIConfig): void;
+    get isConfigured(): boolean;
+    getConfig(): AuthUIConfig | null;
+    /** The configured Appwrite client, for apps that want to reuse it. */
+    getClient(): Client | null;
+    getStrings(): AuthUIStrings;
+    getState(): AuthUIState;
+    get user(): Models.User<Models.Preferences> | null;
+    on<K extends AuthUIEventName>(event: K, listener: Listener<K>): () => void;
+    private emit;
+    private setState;
+    private fail;
+    private acct;
+    /** Re-fetch the current user and derive status. */
+    refresh(): Promise<void>;
+    private afterSignIn;
+    signInWithEmailPassword(email: string, password: string): Promise<void>;
+    signUp(email: string, password: string, name?: string): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    /** Redirects the browser to the provider. Never resolves in a browser. */
+    signInWithOAuth(provider: OAuthProviderName): void;
+    sendMagicUrl(email: string): Promise<Models.Token>;
+    sendEmailOtp(email: string): Promise<Models.Token>;
+    sendPhoneOtp(phone: string): Promise<Models.Token>;
+    /** Redeem any token secret (email OTP, SMS OTP, magic URL, OAuth token). */
+    signInWithToken(userId: string, secret: string): Promise<void>;
+    createMfaChallenge(factor: MfaFactor): Promise<Models.MfaChallenge>;
+    /** Verify a challenge. Completes a pending sign in, or acts as a step-up for protected actions. */
+    completeMfaChallenge(challengeId: string, otp: string, opts?: {
+        signIn?: boolean;
+    }): Promise<void>;
+    listMfaFactors(): Promise<Models.MfaFactors>;
+    setMfaEnabled(enabled: boolean): Promise<void>;
+    addAuthenticator(): Promise<Models.MfaType>;
+    verifyAuthenticator(otp: string): Promise<void>;
+    /** Requires a recent MFA challenge (server rejects with user_challenge_required otherwise). */
+    removeAuthenticator(): Promise<void>;
+    createRecoveryCodes(): Promise<string[]>;
+    /** Requires a recent MFA challenge. */
+    regenerateRecoveryCodes(): Promise<string[]>;
+    /** Requires a recent MFA challenge. */
+    getRecoveryCodes(): Promise<string[]>;
+    sendPasswordRecovery(email: string): Promise<void>;
+    completePasswordRecovery(userId: string, secret: string, password: string): Promise<void>;
+    signOut(sessionId?: string): Promise<void>;
+    signOutEverywhere(): Promise<void>;
+    listSessions(): Promise<Models.Session[]>;
+    listIdentities(): Promise<Models.Identity[]>;
+    deleteIdentity(identityId: string): Promise<void>;
+    listLogs(): Promise<Models.Log[]>;
+    updateName(name: string): Promise<void>;
+    updateEmail(email: string, password: string): Promise<void>;
+    updatePhone(phone: string, password: string): Promise<void>;
+    updatePassword(password: string, oldPassword?: string): Promise<void>;
+    /** Turn an anonymous session into a full account. */
+    convertGuest(email: string, password: string, name?: string): Promise<void>;
+    sendEmailVerification(): Promise<void>;
+    sendPhoneVerification(): Promise<void>;
+    confirmPhoneVerification(otp: string): Promise<void>;
+    /** Blocks the account and ends the session. Appwrite keeps the record so an admin can restore it. */
+    deleteAccount(): Promise<void>;
+    /** Build the URL Appwrite should send the user back to for a given flow. */
+    redirectUrl(action: string): string;
+    setPending(pending: AuthUIPendingAction | null): void;
+    /**
+     * Finish a flow that arrived through the URL. Called automatically by `configure()`.
+     * Returns true when a redirect was handled.
+     */
+    handleRedirect(): Promise<boolean>;
+    private cleanUrl;
+    /** Test helper. */
+    reset(): void;
+}
+
+export declare const authStore: AuthStore;
+
+/** Convenience namespace: `AuthUI.init({...}); AuthUI.open();` */
+export declare const AuthUI: {
+    init: typeof init;
+    open: typeof open_2;
+    close: typeof close_2;
+    signOut: typeof signOut;
+    getUser: typeof getUser;
+    getState: typeof getState;
+    getClient: typeof getClient;
+    on: typeof on;
+    store: AuthStore;
+};
+
+/**
+ * Self-service account management: profile, password, MFA (authenticator app and
+ * recovery codes), sessions, connected OAuth identities, security log and account deletion.
+ */
+export declare class AuthUIAccount extends AuthUIElement {
+    static styles: CSSResult[];
+    /** Set by <authui-modal>; hides the card chrome. */
+    embedded: boolean;
+    tab: Tab;
+    private active;
+    private busy;
+    private notice;
+    private errors;
+    private nameInput;
+    private emailInput;
+    private emailPassword;
+    private phoneInput;
+    private phonePassword;
+    private phoneCode;
+    private phoneCodeSent;
+    private guestName;
+    private oldPassword;
+    private newPassword;
+    private newPasswordConfirm;
+    private authenticator;
+    private authenticatorCode;
+    private factors;
+    private recoveryCodes;
+    private stepUp;
+    private stepUpCode;
+    private copied;
+    private sessions;
+    private identities;
+    private logs;
+    private logsSupported;
+    private confirmDelete;
+    connectedCallback(): void;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    /** Lazily load data for the active tab once a user is available. */
+    private ensureLoaded;
+    private hydrate;
+    private get user();
+    private get isGuest();
+    private select;
+    /** Run an action with a busy key, surfacing errors under that key. Handles MFA step-up. */
+    private run;
+    private loadSessions;
+    private loadIdentities;
+    private loadLogs;
+    private factorsLoading;
+    private loadFactors;
+    private onUpdateName;
+    private onUpdateEmail;
+    private onUpdatePhone;
+    private onConvertGuest;
+    private onSendVerification;
+    private onSendPhoneVerification;
+    private onConfirmPhoneVerification;
+    private onChangePassword;
+    private onToggleMfa;
+    private onAddAuthenticator;
+    private onVerifyAuthenticator;
+    private onRemoveAuthenticator;
+    private onRecoveryCodes;
+    private onRegenerateRecoveryCodes;
+    private onCopyCodes;
+    private onStepUpFactor;
+    private onStepUpVerify;
+    private onDeleteSession;
+    private onSignOutAll;
+    private onDeleteIdentity;
+    private onDeleteAccount;
+    private bind;
+    protected render(): TemplateResult<1>;
+    private renderIdentity;
+    private renderTab;
+    private error;
+    private spinner;
+    private card;
+    private verifiedBadge;
+    private renderProfile;
+    private renderDanger;
+    private renderSecurity;
+    private renderMfaCard;
+    private renderRecoveryCard;
+    /** Inline MFA challenge shown when Appwrite demands a recent factor for a protected action. */
+    private renderStepUp;
+    private deviceIcon;
+    private renderSessions;
+    private renderConnections;
+    private renderActivity;
+}
+
+export declare interface AuthUIBranding {
+    /** Product name shown in headings. */
+    name?: string;
+    /** Logo URL rendered above the form. */
+    logo?: string;
+    /** Color scheme. "auto" follows prefers-color-scheme and an `html.dark` class. Default: "auto". */
+    theme?: AuthUITheme;
+    /** Corner radius scale. Default: "md". */
+    radius?: AuthUIRadius;
+    /** Any CSS color for primary buttons. Default: near-black / near-white. */
+    primary?: string;
+    /** Text color on primary buttons. */
+    primaryForeground?: string;
+}
+
+/**
+ * A button that opens the Auth UI modal.
+ *
+ * <authui-button>Sign in</authui-button>
+ * <authui-button view="sign-up" variant="outline">Create account</authui-button>
+ */
+export declare class AuthUIButton extends AuthUIElement {
+    static styles: CSSResult[];
+    view: AuthUIView;
+    variant: "primary" | "brand" | "outline" | "secondary" | "ghost" | "link";
+    size: "sm" | "md" | "lg";
+    protected render(): TemplateResult<1>;
+}
+
+export declare interface AuthUIConfig {
+    /** Appwrite API endpoint, e.g. https://cloud.appwrite.io/v1 */
+    endpoint: string;
+    /** Appwrite project ID. */
+    project: string;
+    /**
+     * Absolute URL the user returns to after OAuth, magic URL, recovery and verification emails.
+     * Must be on a hostname registered as a web platform in your Appwrite project.
+     * Default: the current page without query string or hash.
+     */
+    redirectUrl?: string;
+    /** Where to navigate after a successful sign in. If omitted the page is not changed. */
+    successUrl?: string;
+    methods?: AuthUIMethods;
+    /** Show the "Sign up" option. Default: true. */
+    signUp?: boolean;
+    /** Ask for a display name during sign up. Default: true. */
+    requireName?: boolean;
+    /** Let users enroll and manage MFA from the account screen. Default: true. */
+    mfa?: boolean;
+    /** Request a security phrase for email OTP and magic URL. Default: true. */
+    securityPhrase?: boolean;
+    /** Extra OAuth scopes per provider. */
+    oauthScopes?: Partial<Record<OAuthProviderName, string[]>>;
+    branding?: AuthUIBranding;
+    legal?: AuthUILegal;
+    /** Override any UI string. */
+    strings?: Partial<AuthUIStrings>;
+}
+
+/**
+ * Declarative configuration. Drop it anywhere in the page:
+ *
+ * <authui-config endpoint="https://cloud.appwrite.io/v1" project="my-project"
+ *   methods="email-password magic-url anonymous oauth:google oauth:github"></authui-config>
+ */
+export declare class AuthUIConfigElement extends LitElement {
+    static styles: CSSResult;
+    endpoint: string;
+    project: string;
+    redirectUrl: string;
+    successUrl: string;
+    /** Space separated list, e.g. "email-password magic-url email-otp phone anonymous oauth:google". */
+    methods: string;
+    signUp: string;
+    requireName: string;
+    mfa: string;
+    securityPhrase: string;
+    name: string;
+    logo: string;
+    theme: string;
+    radius: string;
+    primary: string;
+    primaryForeground: string;
+    termsUrl: string;
+    privacyUrl: string;
+    connectedCallback(): void;
+    protected updated(): void;
+    private configure;
+    toConfig(): AuthUIConfig;
+}
+
+/**
+ * Base class for every Auth UI element: subscribes to the store, resolves theme
+ * and branding onto the host, and exposes `t()` for strings.
+ */
+export declare class AuthUIElement extends LitElement {
+    static styles: CSSResult[];
+    protected auth: AuthUIState;
+    private unsubscribeStore;
+    private unsubscribeTheme;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected get strings(): AuthUIStrings;
+    /** Translate a string key with optional `{placeholders}`. */
+    protected t(key: keyof AuthUIStrings, values?: Record<string, string | number>): string;
+    protected get config(): AuthUIConfig | null;
+    protected get productName(): string;
+    /** Push theme and branding from config onto the host element. */
+    protected applyBranding(): void;
+    /** Emit a composed custom event from this element. */
+    protected fire<T>(name: string, detail?: T): void;
+}
+
+declare interface AuthUIError {
+    message: string;
+    type: string;
+    code: number;
+}
+
+export declare type AuthUIEventMap = {
+    change: AuthUIState;
+    "signed-in": Models.User<Models.Preferences>;
+    "signed-out": undefined;
+    error: {
+        message: string;
+        type: string;
+        code: number;
+    };
+};
+
+export declare type AuthUIEventName = keyof AuthUIEventMap;
+
+export declare interface AuthUILegal {
+    termsUrl?: string;
+    privacyUrl?: string;
+}
+
+export declare interface AuthUIMethods {
+    /** Email + password sign in and sign up. Default: true. */
+    emailPassword?: boolean;
+    /** Passwordless link sent by email. Default: false. */
+    magicUrl?: boolean;
+    /** Passwordless 6-digit code sent by email. Default: false. */
+    emailOtp?: boolean;
+    /** SMS one-time code. Default: false. */
+    phone?: boolean;
+    /** "Continue as guest" anonymous session. Default: false. */
+    anonymous?: boolean;
+    /** OAuth2 providers to show, in order. Default: []. */
+    oauth?: OAuthProviderName[];
+}
+
+/**
+ * Dialog host for the sign-in and account screens. Opens on `AuthUI.open()`, on
+ * `<authui-button>` clicks, and automatically when a redirect needs to finish
+ * (password reset link, failed OAuth attempt).
+ */
+export declare class AuthUIModal extends AuthUIElement {
+    static styles: CSSResult[];
+    /** Whether the dialog is open. Reflects to an attribute. */
+    open: boolean;
+    /** Which screen to show. */
+    view: AuthUIView;
+    /** Close automatically after a successful sign in. Default: true. */
+    closeOnSuccess: boolean;
+    private handledPending;
+    private dialog?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private onOpenEvent;
+    private onCloseEvent;
+    show(view?: AuthUIView): void;
+    hide(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private onSuccess;
+    private onInnerOpen;
+    private onBackdrop;
+    protected render(): TemplateResult<1>;
+}
+
+/** Something the widget must finish after a redirect, e.g. password reset. */
+export declare type AuthUIPendingAction = {
+    type: "reset-password";
+    userId: string;
+    secret: string;
+} | {
+    type: "verify-email";
+    userId: string;
+    secret: string;
+} | {
+    type: "oauth-failed";
+} | {
+    type: "notice";
+    message: string;
+    tone: "success" | "error" | "info";
+};
+
+export declare type AuthUIRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";
+
+/** Renders its children only while a user is signed in. */
+export declare class AuthUISignedIn extends ConditionalElement {
+    protected shouldShow(status: AuthUIStatus): boolean;
+}
+
+/** Renders its children only while nobody is signed in (including while MFA is pending). */
+export declare class AuthUISignedOut extends ConditionalElement {
+    protected shouldShow(status: AuthUIStatus): boolean;
+}
+
+/**
+ * The complete sign-in experience: OAuth, email + password, sign up, passwordless
+ * (magic URL, email OTP, SMS), guest sessions, password recovery and MFA challenges.
+ * Works standalone in the page or inside <authui-modal>.
+ */
+export declare class AuthUISignIn extends AuthUIElement {
+    static styles: CSSResult[];
+    /** Initial screen. */
+    view: Step;
+    /** Set by <authui-modal>; hides the card chrome. */
+    embedded: boolean;
+    private step;
+    private busy;
+    private error;
+    private notice;
+    private showPassword;
+    private token;
+    private challenge;
+    private recovery;
+    private firstInput?;
+    private email;
+    private password;
+    private passwordConfirm;
+    private name;
+    private phone;
+    private code;
+    connectedCallback(): void;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /** React to store transitions: MFA pending, redirect results, sign in. */
+    private syncFromStore;
+    /** Navigate between screens and reset transient state. */
+    go(step: Step): void;
+    private run;
+    private onSignIn;
+    private onSignUp;
+    private onGuest;
+    private onOAuth;
+    private onForgot;
+    private onReset;
+    private onMagicUrl;
+    private onEmailOtp;
+    private onPhoneOtp;
+    private onVerifyCode;
+    private onChooseFactor;
+    private onVerifyFactor;
+    private onCancelMfa;
+    private onSignOut;
+    private bind;
+    protected render(): TemplateResult<1>;
+    private renderHeader;
+    private renderError;
+    private submitButton;
+    private passwordField;
+    private emailField;
+    private codeField;
+    private legal;
+    private backLink;
+    private renderStep;
+    private renderSignedIn;
+    private renderProviders;
+    private renderSignIn;
+    private renderSignUp;
+    private renderForgot;
+    private renderReset;
+    private phraseBox;
+    private renderMagicUrl;
+    private renderCodeEntry;
+    private renderEmailOtp;
+    private renderPhone;
+    private renderMfa;
+}
+
+export declare interface AuthUIState {
+    status: AuthUIStatus;
+    user: Models.User<Models.Preferences> | null;
+    /** Factors available to complete MFA when status is "mfa-required". */
+    mfaFactors: Models.MfaFactors | null;
+    pending: AuthUIPendingAction | null;
+    configured: boolean;
+}
+
+export declare type AuthUIStatus = "loading" | "signed-out" | "signed-in" | "mfa-required";
+
+export declare interface AuthUIStrings {
+    signIn: string;
+    signUp: string;
+    signOut: string;
+    continueAsGuest: string;
+    email: string;
+    password: string;
+    newPassword: string;
+    confirmPassword: string;
+    name: string;
+    phone: string;
+    code: string;
+    forgotPassword: string;
+    noAccount: string;
+    haveAccount: string;
+    or: string;
+    continueWith: string;
+    continueWithEmail: string;
+    sendEmailCode: string;
+    continueWithPhone: string;
+    sendMagicLink: string;
+    sendCode: string;
+    verifyCode: string;
+    magicLinkSent: string;
+    codeSent: string;
+    securityPhrase: string;
+    securityPhraseHint: string;
+    back: string;
+    cancel: string;
+    save: string;
+    update: string;
+    remove: string;
+    close: string;
+    resetPassword: string;
+    resetLinkSent: string;
+    passwordUpdated: string;
+    sendResetLink: string;
+    agreeTo: string;
+    terms: string;
+    privacy: string;
+    and: string;
+    welcomeBack: string;
+    createAccount: string;
+    signInTitle: string;
+    signUpTitle: string;
+    mfaTitle: string;
+    mfaDescription: string;
+    mfaUseAuthenticator: string;
+    mfaUseEmail: string;
+    mfaUsePhone: string;
+    mfaUseRecoveryCode: string;
+    recoveryCode: string;
+    account: string;
+    profile: string;
+    security: string;
+    sessions: string;
+    connections: string;
+    activity: string;
+    dangerZone: string;
+    verified: string;
+    unverified: string;
+    verifyEmail: string;
+    verificationSent: string;
+    emailVerified: string;
+    changePassword: string;
+    currentPassword: string;
+    twoFactor: string;
+    twoFactorDescription: string;
+    enable: string;
+    disable: string;
+    authenticatorApp: string;
+    authenticatorAdd: string;
+    authenticatorScan: string;
+    authenticatorManual: string;
+    authenticatorVerify: string;
+    recoveryCodes: string;
+    recoveryCodesDescription: string;
+    generateRecoveryCodes: string;
+    regenerateRecoveryCodes: string;
+    recoveryCodesWarning: string;
+    currentSession: string;
+    signOutSession: string;
+    signOutAllSessions: string;
+    signOutAllSessionsDescription: string;
+    noConnections: string;
+    disconnect: string;
+    noActivity: string;
+    deleteAccount: string;
+    deleteAccountDescription: string;
+    deleteAccountConfirm: string;
+    loading: string;
+    copied: string;
+    copy: string;
+    done: string;
+    errorGeneric: string;
+    errorInvalidCredentials: string;
+    errorUserExists: string;
+    errorUserBlocked: string;
+    errorRateLimit: string;
+    errorInvalidToken: string;
+    errorInvalidCode: string;
+    errorPasswordMismatch: string;
+    errorPasswordRecentlyUsed: string;
+    errorPasswordPersonalData: string;
+    errorPasswordWeak: string;
+    errorPasswordPwned: string;
+    errorChallengeRequired: string;
+    errorSessionExists: string;
+    errorOAuth: string;
+    errorNetwork: string;
+    errorMethodDisabled: string;
+    errorNotConfigured: string;
+    passwordHint: string;
+    signedInAs: string;
+    manageAccount: string;
+    continue: string;
+    provider: string;
+    lastActive: string;
+    guestAccount: string;
+    guestAccountDescription: string;
+}
+
+export declare type AuthUITheme = "light" | "dark" | "auto";
+
+/**
+ * Avatar with a menu: shows a sign-in button while signed out, and the user's
+ * avatar with "Manage account" and "Sign out" while signed in.
+ */
+export declare class AuthUIUserButton extends AuthUIElement {
+    static styles: CSSResult[];
+    /** Avatar image URL; falls back to initials. */
+    src: string;
+    private menuOpen;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private onDocumentClick;
+    private onKeydown;
+    protected render(): TemplateResult<1>;
+}
+
+/** Screens the widget can show. */
+export declare type AuthUIView = "sign-in" | "sign-up" | "forgot-password" | "reset-password" | "magic-url" | "email-otp" | "phone" | "mfa" | "account";
+
+declare function close_2(): void;
+export { close_2 as close }
+
+export declare function closeModal(): void;
+
+declare abstract class ConditionalElement extends LitElement {
+    protected abstract shouldShow(status: AuthUIStatus): boolean;
+    private show;
+    private unsubscribe;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private evaluate;
+    protected render(): TemplateResult<1> | typeof nothing;
+}
+
+export declare const defaultStrings: AuthUIStrings;
+
+/**
+ * Pick a friendly message for an error, falling back to Appwrite's own text.
+ * Pass `context: "code"` when the user typed a one-time code so an invalid
+ * token reads as "wrong code" instead of "expired link".
+ */
+export declare function describeError(err: unknown, s: AuthUIStrings, context?: "link" | "code"): string;
+
+/** Appwrite error `type` strings the UI reacts to. */
+export declare const ErrorTypes: {
+    readonly moreFactorsRequired: "user_more_factors_required";
+    readonly invalidCredentials: "user_invalid_credentials";
+    readonly userAlreadyExists: "user_already_exists";
+    readonly emailAlreadyExists: "user_email_already_exists";
+    readonly phoneAlreadyExists: "user_phone_already_exists";
+    readonly userBlocked: "user_blocked";
+    readonly rateLimit: "general_rate_limit_exceeded";
+    readonly invalidToken: "user_invalid_token";
+    readonly invalidCode: "user_invalid_code";
+    readonly passwordMismatch: "user_password_mismatch";
+    readonly passwordRecentlyUsed: "password_recently_used";
+    readonly passwordPersonalData: "password_personal_data";
+    readonly passwordWeak: "user_password_weak";
+    readonly passwordPwned: "password_pwned";
+    readonly challengeRequired: "user_challenge_required";
+    readonly recoveryCodesExist: "user_recovery_codes_already_exists";
+    readonly recoveryCodesNotFound: "user_recovery_codes_not_found";
+    readonly authenticatorNotFound: "user_authenticator_not_found";
+    readonly routeNotFound: "general_route_not_found";
+    readonly emailAlreadyVerified: "user_email_already_verified";
+    readonly sessionNotFound: "user_session_not_found";
+    readonly wafChallenged: "waf_request_challenged";
+    readonly sessionAlreadyExists: "user_session_already_exists";
+    readonly oauthUnauthorized: "user_oauth2_unauthorized";
+    readonly oauthBadRequest: "user_oauth2_bad_request";
+    readonly unauthorized: "general_unauthorized_scope";
+    readonly userUnauthorized: "user_unauthorized";
+    readonly authMethodUnsupported: "user_auth_method_unsupported";
+    readonly countMaxExceeded: "user_count_exceeded";
+    readonly targetAlreadyExists: "user_target_already_exists";
+};
+
+export declare function getClient(): Client | null;
+
+export declare function getState(): AuthUIState;
+
+export declare function getUser(): Models.User<Models.Preferences> | null;
+
+/** Configure Auth UI. Call once, as early as possible. */
+export declare function init(config: AuthUIConfig): {
+    init: typeof init;
+    open: typeof open_2;
+    close: typeof close_2;
+    signOut: typeof signOut;
+    getUser: typeof getUser;
+    getState: typeof getState;
+    getClient: typeof getClient;
+    on: typeof on;
+    store: AuthStore;
+};
+
+declare type Listener<K extends AuthUIEventName> = (detail: AuthUIEventMap[K]) => void;
+
+declare type MfaFactor = "totp" | "email" | "phone" | "recoverycode";
+
+/** Every OAuth2 provider slug Appwrite understands. */
+export declare type OAuthProviderName = "amazon" | "apple" | "appwrite" | "auth0" | "authentik" | "autodesk" | "bitbucket" | "bitly" | "box" | "cloudflare" | "dailymotion" | "discord" | "disqus" | "dropbox" | "etsy" | "facebook" | "figma" | "fusionauth" | "github" | "gitlab" | "google" | "huggingface" | "kakao" | "keycloak" | "kick" | "linkedin" | "microsoft" | "notion" | "oidc" | "okta" | "paypal" | "paypalSandbox" | "podio" | "resend" | "salesforce" | "slack" | "spotify" | "stripe" | "tiktok" | "tradeshift" | "tradeshiftBox" | "twitch" | "wordpress" | "x" | "yahoo" | "yammer" | "yandex" | "zoho" | "zoom";
+
+export declare function on<K extends AuthUIEventName>(event: K, listener: (detail: AuthUIEventMap[K]) => void): () => void;
+
+/** Open the modal on a given screen. Creates <authui-modal> if the page has none. */
+declare function open_2(view?: AuthUIView): void;
+export { open_2 as open }
+
+/**
+ * Open the modal from anywhere. If no <authui-modal> exists yet, one is appended to <body>.
+ */
+export declare function openModal(view?: AuthUIView): void;
+
+export declare function providerLabel(provider: string): string;
+
+export declare function signOut(): Promise<void>;
+
+declare type Step = Exclude<AuthUIView, "account">;
+
+declare type Tab = "profile" | "security" | "sessions" | "connections" | "activity";
+
+export declare function toAuthUIError(err: unknown): AuthUIError;
+
+export { }