@webority/ui-elements 0.149.0 → 0.150.0

package/types/razor-js/modules/fileHelpers.d.ts

@@ -0,0 +1,16 @@
+export declare const validate: (file: File, accept: string, maxSizeMb: number) => string | null;
+export declare const maxSizeOf: (raw: string | undefined) => number;
+export declare const isImage: (file: File | undefined) => boolean;
+export declare const isPdf: (file: File | undefined) => boolean;
+export declare const el: <E extends Element>(parent: ParentNode, selector: string, type: abstract new (...args: never[]) => E) => E;
+export declare const formatFileSize: (bytes: number) => string;
+export declare const syncFilesToInput: (input: HTMLInputElement, picked: File[]) => void;
+export declare const createUrlCache: (isImageFn: (file: File) => boolean) => {
+    urlFor(file: File): string | null;
+    revoke(file: File): void;
+    clear(): void;
+};
+export declare const buildAttachListItem: (file: File, { url, onRemove }: {
+    url: string | null;
+    onRemove: () => void;
+}) => HTMLDivElement;

package/types/razor-js/modules/filePickers.d.ts

@@ -0,0 +1,6 @@
+export interface FilePickerHandle {
+    zone: HTMLElement;
+    setLoading: (on: boolean) => void;
+}
+export declare const filePickers: WeakMap<Element, FilePickerHandle>;
+export declare const initFilePickers: (root?: Document | Element) => void;

package/types/razor-js/modules/filterBars.d.ts

@@ -0,0 +1 @@
+export declare const initFilterBars: () => void;

package/types/razor-js/modules/imagePickers.d.ts

@@ -0,0 +1 @@
+export declare const initImagePickers: (root?: Document | Element) => void;

package/types/razor-js/modules/inputs.d.ts

@@ -0,0 +1,10 @@
+export declare const initNumberInputs: (root?: Document | Element) => void;
+export declare const initPasswordToggles: (root?: Document | Element) => void;
+export declare const initPasswordRequirements: (root?: Document | Element) => void;
+export declare const initConfirmPhrases: (root?: Document | Element) => void;
+export declare const initClearables: (root?: Document | Element) => void;
+export declare const initSearch: (root?: Document | Element) => void;
+export declare const initSegmented: (root?: Document | Element) => void;
+export declare const initCounters: (root?: Document | Element) => void;
+export declare const initAutosize: (root?: Document | Element) => void;
+export declare const initValidatorMirrors: () => void;

package/types/razor-js/modules/look.d.ts

@@ -0,0 +1,6 @@
+declare const fromAddress: (url: string) => Promise<string>;
+export declare const look: {
+    apply: (file: unknown) => string;
+    fromAddress: typeof fromAddress;
+};
+export {};

package/types/razor-js/modules/overlays.d.ts

@@ -0,0 +1,5 @@
+export declare const initOverlayFocus: () => void;
+export declare const initModalInert: () => void;
+export declare const initCommandPalettes: () => void;
+export declare const initDropdownScrollClose: () => void;
+export declare const initDisabledDropdownItems: () => void;

package/types/razor-js/modules/pageListeners.d.ts

@@ -0,0 +1 @@
+declare const chartOf: (node: Element) => import("../../WuiChart").WuiChart | null | undefined;

package/types/razor-js/modules/popovers.d.ts

@@ -0,0 +1 @@
+export declare const initPopoversAndTooltips: (root?: Document | Element) => void;

package/types/razor-js/modules/serverBridge.d.ts

@@ -0,0 +1,13 @@
+export declare const initServerTables: (root?: Document | Element) => void;
+export declare const initRemoteModals: (root?: Document | Element) => void;
+export declare const initServerActions: (root?: Document | Element) => void;
+export declare const initInputMasks: (root?: Document | Element) => void;
+export declare const initScrollEdges: (root?: Document | Element) => void;
+export declare const initShellParts: (root?: Document | Element) => void;
+export declare const initUnsavedChanges: (root?: Document | Element) => void;
+export declare const initDrawerDiscard: (root?: Document | Element) => void;
+export declare const initCollapsibleSearch: (root?: Document | Element) => void;
+export declare const initPageBarBulk: (root?: Document | Element) => void;
+export declare const initRowDrag: (root?: Document | Element) => void;
+export declare const initSubmitOnce: (root?: Document | Element) => void;
+export declare const initCommandShortcuts: (root?: Document | Element) => void;

package/types/razor-js/modules/shared.d.ts

@@ -0,0 +1,15 @@
+export declare const ready: (fn: () => void) => void;
+export declare const qsa: <E extends HTMLElement>(root: ParentNode, selector: string, type: abstract new (...args: never[]) => E) => E[];
+export declare const onTeardown: (node: Element, release: () => void) => void;
+export declare const plainPopoverTitle: (bs: {
+    Popover?: {
+        Default?: {
+            template?: string;
+        };
+    };
+}) => void;
+export declare const wuiIcon: (name: string, size?: number) => string;
+export declare const fadeOutError: (node: Element) => void;
+export declare const setFieldError: (host: HTMLElement | null, message: string, { errorClassEl }?: {
+    errorClassEl?: Element;
+}) => void;

package/types/razor-js/modules/shell.d.ts

@@ -0,0 +1 @@
+export declare const initShell: () => void;

package/types/razor-js/modules/splitView.d.ts

@@ -0,0 +1,2 @@
+export declare const initSplitViewEvents: () => void;
+export declare const initSplitViews: (root?: ParentNode) => void;

package/types/razor-js/modules/tables.d.ts

@@ -0,0 +1,9 @@
+export declare const initSelectableTables: (root?: ParentNode) => void;
+export declare const initSortableTables: (root?: ParentNode) => void;
+export declare const initTableToolbars: () => void;
+export declare const markRowLinks: (root?: ParentNode) => void;
+export declare const labelStackedTables: (root?: ParentNode) => void;
+export declare const initColumnMenus: (root?: ParentNode) => void;
+export declare const initRowLinks: () => void;
+export declare const initClippedNameTitles: () => void;
+export declare const initCompareScrollEdges: (root?: ParentNode) => void;

package/types/razor-js/modules/tabs.d.ts

@@ -0,0 +1 @@
+export declare const initTabs: (root?: ParentNode) => void;

package/types/razor-js/modules/themeCopy.d.ts

@@ -0,0 +1,2 @@
+export declare const initThemeToggles: () => void;
+export declare const initCopyButtons: () => void;

package/types/razor-js/modules/toast.d.ts

@@ -0,0 +1,3 @@
+import type { ToastOptions } from "../../toastTypes.ts";
+export declare const toast: (message: string, opts?: ToastOptions) => HTMLElement | null;
+export declare const dismissAllToasts: () => void;

package/types/razor-js/modules/validation.d.ts

@@ -0,0 +1,11 @@
+export declare const initErrorSummaryOrder: (root?: ParentNode) => void;
+export declare const initErrorSummaries: () => void;
+export declare const initServerFieldErrors: () => void;
+interface ErrorSummaryItem {
+    field?: string;
+    message: string;
+}
+export declare const showErrorSummary: (form: HTMLFormElement, errors: readonly ErrorSummaryItem[] | null | undefined, opts?: {
+    title?: string;
+}) => HTMLElement | null;
+export {};

package/types/razor-js/modules/widgets.d.ts

@@ -0,0 +1,9 @@
+export declare const initChipRemove: (root?: ParentNode) => void;
+export declare const initActionIconFiles: () => void;
+export declare const initRepeaterSubmit: () => void;
+export declare const initWorkspaceSwitchers: (root?: ParentNode) => void;
+export declare const initBannerDismiss: (root?: ParentNode) => void;
+export declare const initCardClose: (root?: ParentNode) => void;
+export declare const initAccordions: (root?: ParentNode) => void;
+export declare const initVibrateTaps: () => void;
+export declare const initDataStyles: (root?: ParentNode) => void;

package/types/razor-js/webority-ui.d.ts

@@ -0,0 +1,48 @@
+import "./modules/pageListeners.ts";
+import { dismissAllToasts, toast } from "./modules/toast.ts";
+import { showErrorSummary } from "./modules/validation.ts";
+declare const refresh: (root?: Document | Element) => void;
+declare const wui: {
+    modal: {
+        open: (id: string) => void;
+        close: (id: string) => void;
+        load: (url: string, options?: import("./modules/api.ts").RemoteOptions) => Promise<import("../server/remoteModal.ts").ModalHandle>;
+    };
+    drawer: {
+        load: (url: string, options?: import("./modules/api.ts").RemoteOptions) => Promise<import("../server/remoteModal.ts").ModalHandle>;
+    };
+    pane: {
+        load: (url: string, options?: import("./modules/api.ts").RemoteOptions) => Promise<import("../server/remoteModal.ts").ModalHandle>;
+        close: (target: string | Element) => void;
+    };
+    tour: {
+        seenStore: import("./modules/api.ts").TourSeenStore | null;
+        start: (id: string) => unknown;
+    };
+    table: {
+        get: (target: string | Element) => import("../server/serverTable.ts").ServerTableHandle;
+    };
+    shell: {
+        get: (target?: string | Element) => import("../server/shellParts.ts").ShellHandle;
+    };
+    filePicker: {
+        setLoading: (target: string | Element, on: boolean) => void;
+    };
+    unsaved: {
+        reset: (target: string | Element) => void;
+    };
+    toast: typeof toast;
+    dismissAllToasts: typeof dismissAllToasts;
+    showErrorSummary: typeof showErrorSummary;
+    look: {
+        apply: (file: unknown) => string;
+        fromAddress: (url: string) => Promise<string>;
+    };
+    refresh: typeof refresh;
+};
+export type WuiApi = typeof wui;
+declare global {
+    interface WuiHost extends WuiApi {
+    }
+}
+export {};

package/types/relativeTime.d.ts

@@ -0,0 +1,10 @@
+/** A time further than this from now reads as its date (DD-MMM-YYYY), not as a count. */
+export declare const RELATIVE_LIMIT_DAYS: number;
+/**
+ * "just now", "5 minutes ago", "in 2 hours", "3 days ago"; a week or more away it is the date
+ * (04-Oct-2026). `value` is anything `toInstant` takes; a missing or unreadable one is "-".
+ * A bare "YYYY-MM-DD" is midnight IST, so pass a full instant when the hour matters.
+ */
+export declare function formatRelativeTime(value: unknown, now?: number): string;
+/** The exact time for the tooltip: "04-Oct-2026 14:05 IST", or "-" when the value is unreadable. */
+export declare function relativeTimeTitle(value: unknown): string;

package/types/richText.d.ts

@@ -0,0 +1,2 @@
+import { WuiRichText } from "./WuiRichText.ts";
+export { WuiRichText };

package/types/richTextAdapter.d.ts

@@ -0,0 +1,54 @@
+import { type StarterKitOptions } from "@tiptap/starter-kit";
+type HeadingLevel = NonNullable<Exclude<StarterKitOptions["heading"], false | undefined>["levels"]>[number];
+export declare const HEADING_LEVELS: HeadingLevel[];
+export declare const LINK_PROTOCOLS: string[];
+export interface CreateEditorOptions {
+    /** Where the editable surface is mounted. */
+    element: HTMLElement;
+    /** The starting value, in `format`. */
+    content: string;
+    format: "html" | "markdown";
+    /** Read on every empty-state paint. */
+    placeholder: () => string;
+    editable: boolean;
+    /** Set on the editable surface (role, aria-*). */
+    attributes: Record<string, string>;
+    /** The document changed. */
+    onChange: () => void;
+    /** The caret, selection or active marks changed. */
+    onSelection: () => void;
+    onBlur: () => void;
+}
+export interface EditorState {
+    bold: boolean;
+    italic: boolean;
+    code: boolean;
+    heading2: boolean;
+    heading3: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    blockquote: boolean;
+    codeBlock: boolean;
+    link: boolean;
+    undo: boolean;
+    redo: boolean;
+}
+export interface EditorHandle {
+    getValue(): string;
+    setValue(value: string | null | undefined): void;
+    setEditable(value: boolean): void;
+    setAttributes(next: Record<string, string>): void;
+    refreshPlaceholder(): void;
+    focus(): void;
+    isEmpty(): boolean;
+    run(action: string): boolean;
+    state(): EditorState;
+    linkHref(): string;
+    setLink(raw: unknown): boolean;
+    removeLink(): boolean;
+    destroy(): void;
+}
+export declare function normalizeHref(raw: unknown): string;
+export declare const ACTION_NAMES: string[];
+export declare function createEditor({ element, content, format, placeholder, editable, attributes, onChange, onSelection, onBlur, }: CreateEditorOptions): EditorHandle;
+export {};

package/types/richTextIcons.d.ts

@@ -0,0 +1 @@
+export declare const RICH_TEXT_ICONS: Readonly<Record<string, string>>;

package/types/rowDrop.d.ts

@@ -0,0 +1,12 @@
+export declare const ROW_DROP_EVENT = "wui:row-drop";
+export declare const DROP_OVER_CLASS = "is-drop-over";
+export declare const ROW_DRAG_TYPE = "application/x-wui-rows";
+type DragKeys = (string | undefined)[];
+export declare function tickedKeys(root: Element): DragKeys;
+/** Make the rows of `root` draggable onto drop targets. Returns the function that removes the listeners. */
+export declare function attachRowDrag(root: HTMLElement): () => void;
+/** Label the drop targets under `doc` for the current selection. Idempotent. */
+export declare function syncTargets(doc?: ParentNode): void;
+/** Wire every `data-wui-row-drag` table under `root` and label the drop targets. Idempotent. */
+export declare function initRowDrag(root?: ParentNode & Node): void;
+export {};

package/types/scrollEdges.d.ts

@@ -0,0 +1,10 @@
+/** Every table scroller the edge cue applies to: the library's data table and Bootstrap's responsive wrappers. */
+export declare const SCROLL_EDGE_SELECTOR = ".table-wrap, .table-responsive, [class*=\"table-responsive-\"]";
+/**
+ * Track one scroller's overflow edges until the returned detach is called.
+ * @param el The scroll container.
+ * @returns Detach: removes the listeners and the attributes.
+ */
+export declare function attachScrollEdges(el: HTMLElement): () => void;
+/** Track every table scroller under `root` once, and keep tracking the ones added later; the Razor behaviour layer's entry point. */
+export declare function initScrollEdges(root?: ParentNode): void;

package/types/select/chips.d.ts

@@ -0,0 +1,2 @@
+import type { SelectPart } from "./part.ts";
+export default function createChipsPart(): Required<Pick<SelectPart, "mount" | "onKey" | "onQuery" | "onPick" | "renderValue" | "actionRow" | "onBlur" | "teardown">>;

package/types/select/country.d.ts

@@ -0,0 +1,2 @@
+import type { SelectPart } from "./part.ts";
+export default function createCountryPart(): Required<Pick<SelectPart, "mount" | "onQuery" | "teardown">>;

package/types/select/customRule.d.ts

@@ -0,0 +1,3 @@
+import type { SelectHost } from "./part.ts";
+export declare const compilePattern: (source: string) => RegExp | null;
+export declare const customEntryError: (host: HTMLElement & Pick<SelectHost, "validate">, text: string) => string;

package/types/select/list.d.ts

@@ -0,0 +1,32 @@
+import type { SelectOption } from "./option.ts";
+type ActionRow = {
+    position: "top" | "bottom";
+    label: string;
+    value: string;
+};
+type Recents = {
+    label: string;
+    options: SelectOption[];
+} | null;
+/**
+ * The options whose label, description or meta contains the query, ignoring case. An empty query keeps every option.
+ */
+export declare function filterOptions(options: SelectOption[], query: string): SelectOption[];
+/**
+ * Draws the listbox. Rows are filtered by `query`; a part that owns filtering passes "" and its own rows.
+ * The empty row shows when no option row or action row is drawn, or when status is "empty"; the loading
+ * row replaces it while status is "loading", and the hint row replaces it while status is "hint".
+ * `recents` draws a heading, its rows and a divider above the full list.
+ * @param listEl the listbox (.wui-select-options); its id prefixes each row id
+ */
+export declare function renderOptions(listEl: HTMLElement, options: SelectOption[], view?: {
+    selected?: string[];
+    query?: string;
+    status?: "idle" | "loading" | "empty" | "hint";
+    emptyText?: string;
+    searchingText?: string;
+    hintText?: string;
+    actionRow?: ActionRow[];
+    recents?: Recents;
+}): void;
+export {};

package/types/select/option.d.ts

@@ -0,0 +1,21 @@
+/** One row of a select list, in every mode. */
+export interface SelectOption {
+    value: string;
+    label: string;
+    /** second line under the label */
+    description?: string;
+    /** trailing text at the row's end (a code, a dial code) */
+    meta?: string;
+    /** the grey group label the row sits under */
+    group?: string;
+    icon?: string;
+    avatar?: string;
+    initials?: string;
+    /** ISO 3166 alpha-2 code, drawn as .wui-flag-<iso> (country mode) */
+    flag?: string;
+    disabled?: boolean;
+    disabledHint?: string;
+}
+export declare const MODES: readonly string[];
+/** true where the value is a list (multiple, tag) */
+export declare const isListMode: (mode: string) => boolean;

package/types/select/part.d.ts

@@ -0,0 +1,103 @@
+import type { SelectOption } from "./option.ts";
+export interface SelectRefs {
+    /** the bordered trigger (.wui-select-control) */
+    control: HTMLElement;
+    /** the value area inside the control (.wui-select-value) */
+    value: HTMLElement;
+    /** the popup (.wui-select-menu) */
+    menu: HTMLElement;
+    /** the listbox (.wui-select-options) */
+    list: HTMLElement;
+    /** the input inside the in-menu search wrapper (.wui-select-search), or null */
+    search: HTMLInputElement | null;
+    /** the inline draft input in tag mode (.wui-select-draft), or null; created by the chips part */
+    input: HTMLInputElement | null;
+}
+/** What the host offers a part. Every member is on the WuiSelect instance itself. */
+export interface SelectHost {
+    /** "single" | "multiple" | "search" | "tag" | "country" */
+    mode: "single" | "multiple" | "search" | "tag" | "country";
+    /** string, or string[] in multiple and tag */
+    value: string | string[];
+    /** the current option list (property, declared children, or a part's) */
+    options: SelectOption[];
+    /** the current search or draft text, "" when none */
+    _query: string;
+    /** the search or draft text changed: runs the query through the parts, then redraws the list */
+    _onQueryChange: (query: string) => void;
+    /** a script-side loader (search and tag suggestions), or null */
+    loadOptions: ((query: string, opts: {
+        signal: AbortSignal;
+    }) => Promise<SelectOption[]>) | null;
+    /**
+     * a script-side check for custom entries, run after `pattern`: true accepts, a non-empty string
+     * refuses with that message, anything else refuses with `invalid-message`
+     */
+    validate: ((value: string) => unknown) | null;
+    /** sets the value, syncs the form mirror, re-renders the value area and list, dispatches "change" with detail { isCustom } */
+    commit: (value: string | string[], meta?: {
+        isCustom: boolean;
+    }) => void;
+    /** replaces the option list a part supplies (search results, the country dataset); re-renders the list; never closes the menu */
+    setPartOptions: (list: SelectOption[]) => void;
+    /**
+     * shows the loading row (searching-text), the empty row (empty-text), the hint row (hint-text,
+     * default "Type to search…", shown while the query is shorter than min-chars), or none
+     */
+    setStatus: (status: "idle" | "loading" | "empty" | "hint") => void;
+    renderList: () => void;
+    openMenu: () => void;
+    closeMenu: (opts?: {
+        focusControl?: boolean;
+    }) => void;
+    /** the message under the control (.wui-select-error), null clears */
+    setError: (message: string | null) => void;
+}
+/**
+ * A mode part. Every hook but mount and teardown is optional; the host runs its own behaviour when a
+ * hook is absent or returns false.
+ */
+export interface SelectPart {
+    /**
+     * options.carry hands back the draft and search text a remount is replacing, so the new part restores them
+     * without a remote search; the host passes it on every mount
+     */
+    mount: (host: HTMLElement & SelectHost, refs: SelectRefs, options?: {
+        carry?: {
+            draft: string;
+            query: string;
+        };
+    }) => void;
+    /** runs before the list's keyboard handling; true when the part handled the key */
+    onKey?: (e: KeyboardEvent) => boolean;
+    /** the search or draft text changed; true when the part owns filtering (it fetches and calls setPartOptions) */
+    onQuery?: (query: string) => boolean;
+    /** the host's option list changed; a search answered by the page ends its loading row */
+    onOptions?: () => void;
+    /** a row was chosen; true when the part committed it (list modes toggle and keep the menu open) */
+    onPick?: (option: SelectOption, meta?: {
+        isCustom: boolean;
+    }) => boolean;
+    /** draw the value area (chips); true when drawn, else the host draws the single value text */
+    renderValue?: () => boolean;
+    /**
+     * an extra row: tag's "Create '{text}'" at the top, search's "Add '{query}'" at the bottom; picking it calls onPick with { value, label } and meta isCustom
+     */
+    actionRow?: (query: string) => {
+        position: "top" | "bottom";
+        label: string;
+        value: string;
+    } | null;
+    /** the menu opened (search: min-chars 0 loads the first page; a query cut off by a disconnect re-runs) */
+    onOpen?: () => void;
+    /** focus left the control; true when the part handled it (allow-custom commits a valid draft) */
+    onBlur?: () => boolean;
+    /**
+     * the rows of recently chosen options drawn above the list while the search box is empty, with their heading; null for none
+     */
+    recents?: (options: SelectOption[]) => {
+        label: string;
+        options: SelectOption[];
+    } | null;
+    teardown: () => void;
+}

package/types/select/partRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { SelectPart } from "./part.ts";
+export declare function registerSelectPart(key: string, part: {
+    default: () => SelectPart;
+}): void;
+export declare function selectPart(key: string): {
+    default: () => SelectPart;
+} | undefined;

package/types/select/parts.d.ts

@@ -0,0 +1 @@
+export declare function importSelectPart(key: string): Promise<unknown>;

package/types/select/partsGlobal.d.ts

@@ -0,0 +1,4 @@
+import type { SelectPart } from "./part.ts";
+export declare function importSelectPart(key: string): Promise<{
+    default: () => SelectPart;
+}>;

package/types/select/recents.d.ts

@@ -0,0 +1,2 @@
+import type { SelectPart } from "./part.ts";
+export default function createRecentsPart(): SelectPart;

package/types/select/remote.d.ts

@@ -0,0 +1,2 @@
+import type { SelectHost } from "./part.ts";
+export declare const searchesRemotely: (host: HTMLElement & SelectHost) => boolean;

package/types/select/search.d.ts

@@ -0,0 +1,5 @@
+import type { SelectPart } from "./part.ts";
+export type SearchPart = SelectPart & Required<Pick<SelectPart, "onQuery" | "onOpen" | "onBlur" | "onPick" | "actionRow" | "renderValue">> & {
+    onOptions: () => void;
+};
+export default function createSearchPart(): SearchPart;

package/types/server/drawerDiscard.d.ts

@@ -0,0 +1,9 @@
+export declare const DISCARD_TEXT: Readonly<{
+    question: string;
+    discard: string;
+    keep: string;
+}>;
+export declare const DISCARD_EVENT: string;
+export declare function createDiscardPrompt(doc: Document, text: string | null): HTMLDivElement;
+/** Wire the discard guard once per document; the Razor behaviour layer calls it on load and refresh. */
+export declare function initDrawerDiscard(root?: Document | Element): void;

package/types/server/index.d.ts

@@ -0,0 +1,9 @@
+export { createDiscardPrompt, DISCARD_EVENT, DISCARD_TEXT, initDrawerDiscard } from "./drawerDiscard.ts";
+export { closeRemotePane, initRemoteModals, loadRemoteDrawer, loadRemoteModal, loadRemotePane } from "./remoteModal.ts";
+export { CONFIRM_DIALOG_ID, CONFIRM_TONES, confirmAction, FLASH_STORAGE_KEY, FLASH_VARIANTS, initServerActions, SERVER_ACTION_TEXT, } from "./serverActions.ts";
+export { getServerTable, initServerTables } from "./serverTable.ts";
+export { getShell, initShellParts } from "./shellParts.ts";
+export { runToastAction, showResultToast, TOAST_ACTION_MS } from "./toastAction.ts";
+export { parseToastAction, TOAST_ACTION_METHODS } from "./toastHeader.ts";
+export { formValues, initUnsavedChanges, resetUnsavedChanges, UNSAVED_TEXT } from "./unsavedChanges.ts";
+export { CSRF_META_NAME, classifyStatus, configureCsrf, createRequestQueue, DEFAULT_CSRF_HEADER, HTTP_KINDS, readCsrf, WUI_HEADERS, wuiFetch, } from "./wuiHttp.ts";

package/types/server/remoteModal.d.ts

@@ -0,0 +1,96 @@
+type SizeName = "sm" | "md" | "lg" | "xl";
+type TextKey = "loading" | "close" | "retry" | "errorTitle" | "forbidden" | "client" | "server" | "network" | "submitFailed" | "invalid";
+type Container = "modal" | "drawer" | "pane";
+type Detail = Record<string, unknown>;
+type CloseStatus = "success" | "dismissed";
+type FetchOutcome = "loaded" | "error" | "aborted" | "session";
+type SizeSpec = {
+    fullscreen: true;
+} | {
+    fullscreen?: false;
+    px: number;
+};
+interface SessionClose {
+    status: CloseStatus;
+    detail: Detail | null;
+}
+export interface ModalHandle {
+    el: HTMLElement;
+    close: () => void;
+    reload: () => Promise<FetchOutcome>;
+    closed: Promise<SessionClose>;
+}
+export interface RemoteOptions {
+    size?: string | number;
+    title?: string;
+    staticBackdrop?: boolean;
+    placement?: string;
+    container?: Container;
+    trigger?: HTMLElement | null;
+    target?: Element | string | null;
+    method?: string;
+    body?: BodyInit;
+    signal?: AbortSignal;
+    onSuccess?: (detail: Detail, handle: ModalHandle) => void;
+    navigate?: (url: string) => void;
+}
+/** Id of the shared dialog `load()` creates on first use. */
+export declare const REMOTE_SHELL_ID: string;
+/** Id of the shared drawer `loadRemoteDrawer()` creates on first use. */
+export declare const REMOTE_DRAWER_ID: string;
+/** Drawer widths, identical to the wui-drawer sizes in _drawer.scss. */
+export declare const DRAWER_SIZE_PX: Readonly<Record<SizeName, number>>;
+/** Shell class of a fullscreen modal; the same class React's AppModal puts on its shell. */
+export declare const FULLSCREEN_CLASS: string;
+/** Card max-widths, identical to ModalSize.cs and React's SIZE_PX. */
+export declare const MODAL_SIZE_PX: Readonly<Record<SizeName, number>>;
+/** The words the dialog shows on its own. */
+export declare const REMOTE_MODAL_TEXT: Readonly<Record<TextKey, string>>;
+/**
+ * A size as the shell applies it: `{ fullscreen: true }` or `{ px }`. Empty is null (no opinion).
+ * An unknown value throws: the vocabulary is sm | md | lg | xl | fullscreen | a positive px number.
+ */
+export declare function resolveModalSize(size: string | number | null | undefined): SizeSpec | null;
+/** A drawer size as the shell applies it: sm | md | lg | xl are drawer widths, or a positive px number. Empty is null. */
+export declare function resolveDrawerSize(size: string | number | null | undefined): SizeSpec | null;
+export declare function wrapTab(shell: HTMLElement, e: KeyboardEvent): void;
+/** Wire the remote modal shells and the delegated trigger under `root`. */
+export declare function initRemoteModals(root?: Document | Element): void;
+/**
+ * Load `url` into the shared remote modal.
+ *
+ * @param {string} url Fragment URL (a page handler answering `this.ModalPartial(...)`).
+ * @param {{ size?: 'sm'|'md'|'lg'|'xl'|'fullscreen'|number, title?: string,
+ *   staticBackdrop?: boolean (defaults to true: Escape and an outside click leave it open; false lets them close it),
+ *   placement?: 'center'|'top', trigger?: Element, method?: string, body?: BodyInit, signal?: AbortSignal,
+ *   onSuccess?: (detail: object, handle: object) => void, navigate?: (url: string) => void }} [options]
+ * @returns {Promise<{ el: HTMLElement, close: () => void, reload: () => Promise<string>,
+ *   closed: Promise<{ status: 'success'|'dismissed', detail: object|null }> }>}
+ */
+export declare function loadRemoteModal(url: string, options?: RemoteOptions): Promise<ModalHandle>;
+/**
+ * Load `url` into the shared remote drawer: the same fragment, submit and answers as
+ * `loadRemoteModal`, docked to the end edge. `WUI.drawer.load`.
+ *
+ * @param {string} url Fragment URL (a page handler answering `this.ModalPartial(...)`).
+ * @param {{ size?: 'sm'|'md'|'lg'|'xl'|number, title?: string,
+ *   staticBackdrop?: boolean (defaults to true: Escape and an outside click leave it open; false lets them close it), trigger?: Element,
+ *   method?: string, body?: BodyInit, signal?: AbortSignal, onSuccess?: (detail: object, handle: object) => void,
+ *   navigate?: (url: string) => void }} [options]
+ */
+export declare function loadRemoteDrawer(url: string, options?: RemoteOptions): Promise<ModalHandle>;
+/** Selector of an in-page pane host (<app-detail-pane>); pane widths are the page's, so it has no size vocabulary. */
+export declare const REMOTE_PANE_HOST: string;
+/**
+ * Load `url` into the in-page pane `options.target` (an element or selector carrying data-wui-pane-host):
+ * the same fragment, submit protocol and answers as loadRemoteModal, with no backdrop.
+ * @param {string} url
+ * @param {{ target: Element|string, trigger?: Element, method?: string, body?: BodyInit, signal?: AbortSignal,
+ *   onSuccess?: (detail: object, handle: object) => void, navigate?: (url: string) => void }} options
+ * @returns {Promise<{ el: HTMLElement, close: () => void, reload: () => Promise<string>,
+ *   closed: Promise<{ status: 'success'|'dismissed', detail: object|null }> }>}
+ */
+export declare function loadRemotePane(url: string, options?: RemoteOptions): Promise<ModalHandle>;
+/** Close the pane `target` (element or selector); a closed pane is left as it is. */
+export declare function closeRemotePane(target: Element | string | null | undefined): void;
+export {};