domma-js 0.56.0 → 0.58.0

package/assets/types/generated/src/auth.d.ts

@@ -0,0 +1,424 @@
+/**
+ * Options for `A.init()`.
+ * @typedef {object} AuthOptions
+ * @property {string} [apiUrl] - Backend API URL (default: `http://<host>:3000/api` on localhost, else `<origin>/api`)
+ * @property {string} [storageKey='auth_token'] - Storage key for the token
+ * @property {string} [userStorageKey='auth_user'] - Storage key for the user object
+ * @property {boolean} [autoCheck=true] - Verify a stored token with `GET <apiUrl>/auth/me` on init
+ */
+/**
+ * The signed-in user, as the backend returned it (`response.user` from login, register or
+ * `/auth/me`). Domma reads `email` and `role`; anything else is the backend's.
+ * @typedef {{email?: string, name?: string, role?: string, [key: string]: any}} AuthUser
+ */
+/**
+ * Events `A.on()` can listen for: `login` / `register` (data: the user), `logout` (null),
+ * `error` (the message string) and `tokenExpired` (null - a stored token the server refused on init).
+ * @typedef {'login'|'register'|'logout'|'error'|'tokenExpired'} AuthEventName
+ */
+/**
+ * An auth event handler. Gets the event's data (see AuthEventName).
+ * @callback AuthEventHandler
+ * @param {any} data
+ * @returns {void}
+ */
+/**
+ * The auth module (`A`, `Domma.auth`).
+ * @typedef {object} Auth
+ * @property {string|null} apiUrl - Backend API URL (set by init)
+ * @property {string|null} token - Current JWT, or null
+ * @property {AuthUser|null} user - Current user, or null
+ * @property {AuthOptions} config - Resolved configuration (set by init)
+ * @property {Record<string, AuthEventHandler[]>} eventHandlers - Registered handlers by event name
+ * @property {boolean} initialized - Whether init() has run
+ * @property {(config?: AuthOptions) => void} init - Initialise the module: load the stored token and user, and (autoCheck) verify the token
+ * @property {(email: string, password: string) => Promise<AuthUser>} login - Log in (`POST <apiUrl>/auth/login`); stores the token and user and emits `login`. Rejects on failure (and emits `error`)
+ * @property {(email: string, password: string, name: string) => Promise<AuthUser>} register - Register (`POST <apiUrl>/auth/register`); stores the token and user and emits `register`. Rejects on failure (and emits `error`)
+ * @property {() => void} logout - Clear the token and user and emit `logout`
+ * @property {() => AuthUser|null} getUser - Current user or null
+ * @property {() => boolean} isAuthenticated - True when there is both a token and a user
+ * @property {() => {Authorization?: string}} getHeaders - `{Authorization: 'Bearer <token>'}`, or `{}` without a token
+ * @property {() => string|null} getApiUrl - The backend API URL
+ * @property {() => string|null} getRole - Current user's role ('admin', 'subscriber', 'guest') or null
+ * @property {(role: string) => boolean} hasRole - Whether the user has this role
+ * @property {(roles: string[]) => boolean} hasAnyRole - Whether the user has any of these roles
+ * @property {() => boolean} isAdmin - Role is 'admin'
+ * @property {() => boolean} isSubscriber - Role is 'subscriber'
+ * @property {() => boolean} isGuest - Role is 'guest'
+ * @property {(event: AuthEventName|(string & {}), callback: AuthEventHandler) => void} on - Subscribe to an event
+ * @property {(event: AuthEventName|(string & {}), callback?: AuthEventHandler) => void} off - Unsubscribe one handler, or every handler of the event when none is given
+ * @property {typeof LoginForm} LoginForm - Login form component class
+ * @property {typeof RegisterForm} RegisterForm - Registration form component class
+ * @property {typeof AuthTabs} AuthTabs - Login/Register tab switcher component class
+ * @property {typeof UserInfo} UserInfo - Signed-in user display with a logout button
+ * @property {(selector: string|HTMLElement, options?: LoginFormOptions) => LoginForm} createLoginForm - Create a LoginForm
+ * @property {(selector: string|HTMLElement, options?: RegisterFormOptions) => RegisterForm} createRegisterForm - Create a RegisterForm
+ * @property {(selector: string|HTMLElement, options?: AuthTabsOptions) => AuthTabs} createAuthTabs - Create an AuthTabs
+ * @property {(selector: string|HTMLElement, options?: UserInfoOptions) => UserInfo} createUserInfo - Create a UserInfo
+ */
+/**
+ * Options for `A.createLoginForm()` / `new A.LoginForm()`.
+ * @typedef {object} LoginFormOptions
+ * @property {string} [emailPlaceholder='your@email.com']
+ * @property {string} [passwordPlaceholder='Enter your password']
+ * @property {string} [buttonText='Login']
+ * @property {boolean} [showLabels=true]
+ * @property {((email: string, password: string) => void)|null} [onSubmit] - Called before the login request
+ * @property {((user: AuthUser|null) => void)|null} [onSuccess] - Called after a successful login
+ * @property {((error: Error) => void)|null} [onError] - Called when the login fails
+ */
+/**
+ * Options for `A.createRegisterForm()` / `new A.RegisterForm()`.
+ * @typedef {object} RegisterFormOptions
+ * @property {string} [namePlaceholder='Your name']
+ * @property {string} [emailPlaceholder='your@email.com']
+ * @property {string} [passwordPlaceholder='Create a password']
+ * @property {string} [buttonText='Register']
+ * @property {number} [minPasswordLength=6]
+ * @property {boolean} [showLabels=true]
+ * @property {((email: string, password: string, name: string) => void)|null} [onSubmit] - Called before the register request
+ * @property {((user: AuthUser|null) => void)|null} [onSuccess] - Called after a successful registration
+ * @property {((error: Error) => void)|null} [onError] - Called when registration fails (also for mismatched passwords)
+ */
+/**
+ * Options for `A.createAuthTabs()` / `new A.AuthTabs()`.
+ * @typedef {object} AuthTabsOptions
+ * @property {'login'|'register'} [activeTab='login']
+ * @property {string} [loginText='Login']
+ * @property {string} [registerText='Register']
+ * @property {((tab: string) => void)|null} [onChange] - Called with the tab switched to
+ */
+/**
+ * Options for `A.createUserInfo()` / `new A.UserInfo()`.
+ * @typedef {object} UserInfoOptions
+ * @property {boolean} [showIcon=true]
+ * @property {boolean} [showRole=true]
+ * @property {string} [logoutText='Logout']
+ * @property {(() => void)|null} [onLogout] - Called after the logout button logs out
+ */
+/** @type {Auth} */
+export const auth: Auth;
+/**
+ * LoginForm Component
+ */
+export class LoginForm extends Component {
+    static defaults: {
+        emailPlaceholder: string;
+        passwordPlaceholder: string;
+        buttonText: string;
+        showLabels: boolean;
+        onSubmit: any;
+        onSuccess: any;
+        onError: any;
+    };
+    /**
+     * @param {string|HTMLElement} selector - Container element or selector
+     * @param {LoginFormOptions} [options]
+     */
+    constructor(selector: string | HTMLElement, options?: LoginFormOptions);
+    _init(): void;
+    render(): void;
+    handleSubmit(): Promise<void>;
+}
+/**
+ * RegisterForm Component
+ */
+export class RegisterForm extends Component {
+    static defaults: {
+        namePlaceholder: string;
+        emailPlaceholder: string;
+        passwordPlaceholder: string;
+        buttonText: string;
+        minPasswordLength: number;
+        showLabels: boolean;
+        onSubmit: any;
+        onSuccess: any;
+        onError: any;
+    };
+    /**
+     * @param {string|HTMLElement} selector - Container element or selector
+     * @param {RegisterFormOptions} [options]
+     */
+    constructor(selector: string | HTMLElement, options?: RegisterFormOptions);
+    _init(): void;
+    render(): void;
+    handleSubmit(): Promise<void>;
+}
+/**
+ * AuthTabs Component
+ */
+export class AuthTabs extends Component {
+    static defaults: {
+        activeTab: string;
+        loginText: string;
+        registerText: string;
+        onChange: any;
+    };
+    /**
+     * @param {string|HTMLElement} selector - Container element or selector
+     * @param {AuthTabsOptions} [options]
+     */
+    constructor(selector: string | HTMLElement, options?: AuthTabsOptions);
+    _init(): void;
+    render(): void;
+    /**
+     * @param {string} tab - 'login' or 'register'
+     */
+    switchTab(tab: string): void;
+}
+/**
+ * UserInfo Component
+ */
+export class UserInfo extends Component {
+    static defaults: {
+        showIcon: boolean;
+        showRole: boolean;
+        logoutText: string;
+        onLogout: any;
+    };
+    /**
+     * @param {string|HTMLElement} selector
+     * @param {Object} [options]
+     */
+    constructor(selector: string | HTMLElement, options?: any);
+    _init(): void;
+    _onAuthChange: () => void;
+    render(): void;
+    handleLogout(): void;
+}
+/**
+ * Options for `A.init()`.
+ */
+export type AuthOptions = {
+    /**
+     * - Backend API URL (default: `http://<host>:3000/api` on localhost, else `<origin>/api`)
+     */
+    apiUrl?: string;
+    /**
+     * - Storage key for the token
+     */
+    storageKey?: string;
+    /**
+     * - Storage key for the user object
+     */
+    userStorageKey?: string;
+    /**
+     * - Verify a stored token with `GET <apiUrl>/auth/me` on init
+     */
+    autoCheck?: boolean;
+};
+/**
+ * The signed-in user, as the backend returned it (`response.user` from login, register or
+ * `/auth/me`). Domma reads `email` and `role`; anything else is the backend's.
+ */
+export type AuthUser = {
+    email?: string;
+    name?: string;
+    role?: string;
+    [key: string]: any;
+};
+/**
+ * Events `A.on()` can listen for: `login` / `register` (data: the user), `logout` (null),
+ * `error` (the message string) and `tokenExpired` (null - a stored token the server refused on init).
+ */
+export type AuthEventName = "login" | "register" | "logout" | "error" | "tokenExpired";
+/**
+ * An auth event handler. Gets the event's data (see AuthEventName).
+ */
+export type AuthEventHandler = (data: any) => void;
+/**
+ * The auth module (`A`, `Domma.auth`).
+ */
+export type Auth = {
+    /**
+     * - Backend API URL (set by init)
+     */
+    apiUrl: string | null;
+    /**
+     * - Current JWT, or null
+     */
+    token: string | null;
+    /**
+     * - Current user, or null
+     */
+    user: AuthUser | null;
+    /**
+     * - Resolved configuration (set by init)
+     */
+    config: AuthOptions;
+    /**
+     * - Registered handlers by event name
+     */
+    eventHandlers: Record<string, AuthEventHandler[]>;
+    /**
+     * - Whether init() has run
+     */
+    initialized: boolean;
+    /**
+     * - Initialise the module: load the stored token and user, and (autoCheck) verify the token
+     */
+    init: (config?: AuthOptions) => void;
+    /**
+     * - Log in (`POST <apiUrl>/auth/login`); stores the token and user and emits `login`. Rejects on failure (and emits `error`)
+     */
+    login: (email: string, password: string) => Promise<AuthUser>;
+    /**
+     * - Register (`POST <apiUrl>/auth/register`); stores the token and user and emits `register`. Rejects on failure (and emits `error`)
+     */
+    register: (email: string, password: string, name: string) => Promise<AuthUser>;
+    /**
+     * - Clear the token and user and emit `logout`
+     */
+    logout: () => void;
+    /**
+     * - Current user or null
+     */
+    getUser: () => AuthUser | null;
+    /**
+     * - True when there is both a token and a user
+     */
+    isAuthenticated: () => boolean;
+    /**
+     * - `{Authorization: 'Bearer <token>'}`, or `{}` without a token
+     */
+    getHeaders: () => {
+        Authorization?: string;
+    };
+    /**
+     * - The backend API URL
+     */
+    getApiUrl: () => string | null;
+    /**
+     * - Current user's role ('admin', 'subscriber', 'guest') or null
+     */
+    getRole: () => string | null;
+    /**
+     * - Whether the user has this role
+     */
+    hasRole: (role: string) => boolean;
+    /**
+     * - Whether the user has any of these roles
+     */
+    hasAnyRole: (roles: string[]) => boolean;
+    /**
+     * - Role is 'admin'
+     */
+    isAdmin: () => boolean;
+    /**
+     * - Role is 'subscriber'
+     */
+    isSubscriber: () => boolean;
+    /**
+     * - Role is 'guest'
+     */
+    isGuest: () => boolean;
+    /**
+     * - Subscribe to an event
+     */
+    on: (event: AuthEventName | (string & {}), callback: AuthEventHandler) => void;
+    /**
+     * - Unsubscribe one handler, or every handler of the event when none is given
+     */
+    off: (event: AuthEventName | (string & {}), callback?: AuthEventHandler) => void;
+    /**
+     * - Login form component class
+     */
+    LoginForm: typeof LoginForm;
+    /**
+     * - Registration form component class
+     */
+    RegisterForm: typeof RegisterForm;
+    /**
+     * - Login/Register tab switcher component class
+     */
+    AuthTabs: typeof AuthTabs;
+    /**
+     * - Signed-in user display with a logout button
+     */
+    UserInfo: typeof UserInfo;
+    /**
+     * - Create a LoginForm
+     */
+    createLoginForm: (selector: string | HTMLElement, options?: LoginFormOptions) => LoginForm;
+    /**
+     * - Create a RegisterForm
+     */
+    createRegisterForm: (selector: string | HTMLElement, options?: RegisterFormOptions) => RegisterForm;
+    /**
+     * - Create an AuthTabs
+     */
+    createAuthTabs: (selector: string | HTMLElement, options?: AuthTabsOptions) => AuthTabs;
+    /**
+     * - Create a UserInfo
+     */
+    createUserInfo: (selector: string | HTMLElement, options?: UserInfoOptions) => UserInfo;
+};
+/**
+ * Options for `A.createLoginForm()` / `new A.LoginForm()`.
+ */
+export type LoginFormOptions = {
+    emailPlaceholder?: string;
+    passwordPlaceholder?: string;
+    buttonText?: string;
+    showLabels?: boolean;
+    /**
+     * - Called before the login request
+     */
+    onSubmit?: ((email: string, password: string) => void) | null;
+    /**
+     * - Called after a successful login
+     */
+    onSuccess?: ((user: AuthUser | null) => void) | null;
+    /**
+     * - Called when the login fails
+     */
+    onError?: ((error: Error) => void) | null;
+};
+/**
+ * Options for `A.createRegisterForm()` / `new A.RegisterForm()`.
+ */
+export type RegisterFormOptions = {
+    namePlaceholder?: string;
+    emailPlaceholder?: string;
+    passwordPlaceholder?: string;
+    buttonText?: string;
+    minPasswordLength?: number;
+    showLabels?: boolean;
+    /**
+     * - Called before the register request
+     */
+    onSubmit?: ((email: string, password: string, name: string) => void) | null;
+    /**
+     * - Called after a successful registration
+     */
+    onSuccess?: ((user: AuthUser | null) => void) | null;
+    /**
+     * - Called when registration fails (also for mismatched passwords)
+     */
+    onError?: ((error: Error) => void) | null;
+};
+/**
+ * Options for `A.createAuthTabs()` / `new A.AuthTabs()`.
+ */
+export type AuthTabsOptions = {
+    activeTab?: "login" | "register";
+    loginText?: string;
+    registerText?: string;
+    /**
+     * - Called with the tab switched to
+     */
+    onChange?: ((tab: string) => void) | null;
+};
+/**
+ * Options for `A.createUserInfo()` / `new A.UserInfo()`.
+ */
+export type UserInfoOptions = {
+    showIcon?: boolean;
+    showRole?: boolean;
+    logoutText?: string;
+    /**
+     * - Called after the logout button logs out
+     */
+    onLogout?: (() => void) | null;
+};
+import Component from './component.js';

package/assets/types/generated/src/avatar.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Initials for a name.
+ *
+ *   'Jane Smith'             -> 'JS'   first and last word
+ *   'Jane Q. Public'         -> 'JP'
+ *   'Madonna'                -> 'M'    one word, one letter
+ *   'jane.smith@example.com' -> 'JS'   the part before the @, split on . _ - +
+ *   'Jean-Luc Picard'        -> 'JP'
+ *   'Łukasz Żuk'             -> 'ŁŻ'
+ *   '王小明'                  -> '王'
+ *   '', null, '  !! '        -> ''     nothing to go on: callers show an icon
+ *
+ * Words are split on spaces, dots, underscores, hyphens and plus signs;
+ * anything that is not a letter or digit at the start of a word (quotes,
+ * brackets, emoji) is skipped, and bracketed notes like "(Admin)" are dropped.
+ * @param {string|null|undefined} name
+ * @returns {string}
+ */
+export function avatarInitials(name: string | null | undefined): string;
+/**
+ * The tone (0-7) for a name: FNV-1a over the trimmed, lower-cased, single-spaced
+ * name. Stable across pages, sessions and machines; case and spacing do not
+ * change it, so 'jane smith' and 'Jane  Smith' match.
+ * @param {string} key
+ * @returns {number}
+ */
+export function avatarTone(key: string): number;
+/**
+ * Render one avatar.
+ * @overload
+ * @param {string|Element|ArrayLike<Element>|null} target
+ * @param {AvatarOptions} [options]
+ * @returns {AvatarHandle|null}
+ */
+export function avatar(target: string | Element | ArrayLike<Element> | null, options?: AvatarOptions): AvatarHandle | null;
+/**
+ * Render one avatar into a detached <span> for you to insert.
+ * @overload
+ * @param {AvatarOptions} options
+ * @returns {AvatarHandle}
+ */
+export function avatar(options: AvatarOptions): AvatarHandle;
+export namespace avatar {
+    export { avatarInitials as initials };
+    export { avatarTone as tone };
+    /**
+     * The live handle on an element, if any - the same answer as E.get(target, 'avatar').
+     * @param {string|Element|ArrayLike<Element>} target
+     * @returns {AvatarHandle|null}
+     */
+    export function get(target: string | Element | ArrayLike<Element>): AvatarHandle | null;
+    /**
+     * Turn every `[data-avatar]` under `root` (and `root` itself) into an avatar,
+     * once. Options come from `data-avatar-*`. Returns the new handles.
+     * @param {string|Element|Document} [root]
+     * @returns {AvatarHandle[]}
+     */
+    export function scan(root?: string | Element | Document): AvatarHandle[];
+}
+/**
+ * Render a stack of avatars with a "+N" overflow bubble.
+ *
+ * @param {string|Element|ArrayLike<Element>} target - a <ul>/<ol> to fill, or any element
+ *   to put a new <ul> into (its content comes back on destroy())
+ * @param {AvatarGroupOptions} [options] - see GROUP_DEFAULTS
+ * @returns {AvatarGroupHandle|null} null if nothing matched
+ */
+export function avatarGroup(target: string | Element | ArrayLike<Element>, options?: AvatarGroupOptions): AvatarGroupHandle | null;
+export namespace avatarGroup {
+    /**
+     * The live group handle on a host element (or its list), if any - the same answer as E.get(target, 'avatar-group').
+     * @param {string|Element|ArrayLike<Element>} target
+     * @returns {AvatarGroupHandle|null}
+     */
+    function get(target: string | Element | ArrayLike<Element>): AvatarGroupHandle | null;
+}
+/** @type {AvatarSize[]} */
+export const AVATAR_SIZES: AvatarSize[];
+/** @type {AvatarShape[]} */
+export const AVATAR_SHAPES: AvatarShape[];
+/** @type {AvatarStatus[]} */
+export const AVATAR_STATUSES: AvatarStatus[];
+/** How many `.avatar-tone-*` classes elements.css defines. */
+export const AVATAR_TONES: 8;
+export default avatar;
+export type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type AvatarShape = "circle" | "rounded" | "square";
+export type AvatarStatus = "online" | "away" | "busy" | "offline";
+export type AvatarOptions = {
+    /**
+     * - The person: initials, tone and accessible name come from it
+     */
+    name?: string | null;
+    /**
+     * - Picture URL; falls back to the initials (or icon) if it fails to load
+     */
+    src?: string | null;
+    /**
+     * - Accessible name when it should differ from name
+     */
+    alt?: string | null;
+    /**
+     * - Size (default 'md')
+     */
+    size?: AvatarSize;
+    /**
+     * - Shape (default 'circle')
+     */
+    shape?: AvatarShape;
+    /**
+     * - Status dot; the word goes into the accessible name
+     */
+    status?: AvatarStatus | null;
+    /**
+     * - Words for the statuses in the accessible name, e.g. {busy: 'in a meeting'}
+     */
+    statusLabels?: Partial<Record<AvatarStatus, string>> | null;
+    /**
+     * - Icon name shown instead of initials ('user' when there is no name)
+     */
+    icon?: string | null;
+    /**
+     * - Hover text; true = the accessible name
+     */
+    title?: string | true | null;
+    /**
+     * - A primary-coloured ring (default false)
+     */
+    ring?: boolean;
+    /**
+     * - 0-7 to choose the tint; default is a hash of the name
+     */
+    tone?: number | null;
+    /**
+     * - aria-hidden: the name is written next to it (default false)
+     */
+    decorative?: boolean;
+};
+/**
+ * The handle E.avatar() returns. `options`, `initials`, `tone` and `label` are read only.
+ */
+export type AvatarHandle = {
+    /**
+     * - The avatar element
+     */
+    element: HTMLElement;
+    /**
+     * - The options in force
+     */
+    options: AvatarOptions;
+    /**
+     * - The initials drawn ('' when an icon is shown)
+     */
+    initials: string;
+    /**
+     * - The tone 0-7, or null with nothing to hash
+     */
+    tone: number | null;
+    /**
+     * - The accessible name, e.g. 'Jane Smith (online)'
+     */
+    label: string;
+    /**
+     * - Merge options and redraw
+     */
+    update: (options?: AvatarOptions) => AvatarHandle;
+    /**
+     * - Restore the element's previous children, classes and attributes
+     */
+    destroy: () => HTMLElement;
+};
+/**
+ * `E.avatar` - the factory with `initials`, `tone`, `get` and `scan`.
+ */
+export type AvatarStatic = typeof avatar;
+/**
+ * One person in an avatar group.
+ */
+export type AvatarPerson = {
+    name?: string;
+    src?: string;
+    status?: AvatarStatus;
+    /**
+     * - Makes the avatar a link
+     */
+    href?: string;
+    alt?: string;
+    icon?: string;
+    tone?: number;
+    /**
+     * - Hover text (default: the accessible name)
+     */
+    title?: string | true;
+};
+export type AvatarGroupOptions = {
+    /**
+     * - People, or plain names
+     */
+    people?: Array<AvatarPerson | string>;
+    /**
+     * - Show this many, then "+N"; null = everyone
+     */
+    max?: number | null;
+    /**
+     * - Size (default 'md')
+     */
+    size?: AvatarSize;
+    /**
+     * - Shape (default 'circle')
+     */
+    shape?: AvatarShape;
+    /**
+     * - 'none' | 'sm' | 'md' | 'lg', pixels, or any CSS length; null = the stylesheet's 25%
+     */
+    overlap?: "none" | "sm" | "md" | "lg" | number | string | null;
+    /**
+     * - Accessible name for the list
+     */
+    label?: string | null;
+    statusLabels?: Partial<Record<AvatarStatus, string>> | null;
+    /**
+     * - Called when "+N" is pressed, instead of the popover
+     */
+    onMore?: ((hidden: AvatarPerson[], event: MouseEvent) => void) | null;
+    /**
+     * - false: no popover, the hidden names go in the button's title (default true)
+     */
+    popover?: boolean;
+    /**
+     * - The "+N" button's accessible name (default '3 more: A, B and C')
+     */
+    moreLabel?: ((count: number, names: string[]) => string) | null;
+};
+/**
+ * The handle E.avatarGroup() returns. Everything but the methods is read only.
+ */
+export type AvatarGroupHandle = {
+    /**
+     * - The <ul>
+     */
+    element: HTMLUListElement | HTMLOListElement;
+    options: AvatarGroupOptions;
+    people: AvatarPerson[];
+    /**
+     * - Drawn as avatars
+     */
+    shown: AvatarPerson[];
+    /**
+     * - Folded into "+N"
+     */
+    hidden: AvatarPerson[];
+    /**
+     * - The "+N" button, or null
+     */
+    more: HTMLButtonElement | null;
+    /**
+     * - The "+N" popover, or null
+     */
+    popover: import("./popover.js").PopoverInstance | null;
+    update: (options?: AvatarGroupOptions) => AvatarGroupHandle;
+    setPeople: (people: Array<AvatarPerson | string>) => AvatarGroupHandle;
+    /**
+     * - Remove everything and restore the host
+     */
+    destroy: () => HTMLElement;
+};
+/**
+ * `E.avatarGroup` - the factory with `get`.
+ */
+export type AvatarGroupStatic = typeof avatarGroup;