jhx 0.1.1

package/index.d.ts

@@ -0,0 +1,2054 @@
+import { HttpVerb, HtmxResponseHandlingConfig as HtmxResponseHandlingConfig$1, HtmxSettleInfo as HtmxSettleInfo$1, HtmxAjaxHelperContext, HtmxExtension as HtmxExtension$1, HtmxSwapSpecification, SwapOptions, ConditionalFunction as ConditionalFunction$1 } from 'htmx.org';
+import { DOMAttributes, ElementType, ComponentPropsWithoutRef, PropsWithChildren, JSX } from 'react';
+
+/**
+ * @see https://htmx.org/reference/
+ * @see https://htmx.org/docs/
+ */
+declare const htmx: {
+    readonly attr: {
+        readonly onAbort: "hx-on--abort";
+        readonly onAfterOnLoad: "hx-on--after-on-load";
+        readonly onAfterProcessNode: "hx-on--after-process-node";
+        readonly onAfterRequest: "hx-on--after-request";
+        readonly onAfterSettle: "hx-on--after-settle";
+        readonly onAfterSwap: "hx-on--after-swap";
+        readonly onBeforeCleanupElement: "hx-on--before-cleanup-element";
+        readonly onBeforeOnLoad: "hx-on--before-on-load";
+        readonly onBeforeProcessNode: "hx-on--before-process-node";
+        readonly onBeforeRequest: "hx-on--before-request";
+        readonly onBeforeSwap: "hx-on--before-swap";
+        readonly onBeforeSend: "hx-on--before-send";
+        readonly onBeforeTransition: "hx-on--before-transition";
+        readonly onConfigRequest: "hx-on--config-request";
+        readonly onConfirm: "hx-on--confirm";
+        readonly onHistoryCacheError: "hx-on--history-cache-error";
+        readonly onHistoryCacheHit: "hx-on--history-cache-hit";
+        readonly onHistoryCacheMiss: "hx-on--history-cache-miss";
+        readonly onHistoryCacheMissLoadError: "hx-on--history-cache-miss-load-error";
+        readonly onHistoryCacheMissLoad: "hx-on--history-cache-miss-load";
+        readonly onHistoryRestore: "hx-on--history-restore";
+        readonly onBeforeHistorySave: "hx-on--before-history-save";
+        readonly onLoad: "hx-on--load";
+        readonly onNoSSESourceError: "hx-on--no-sse-source-error";
+        readonly onOnLoadError: "hx-on--on-load-error";
+        readonly onOobAfterSwap: "hx-on--oob-after-swap";
+        readonly onOobBeforeSwap: "hx-on--oob-before-swap";
+        readonly onOobErrorNoTarget: "hx-on--oob-error-no-target";
+        readonly onPrompt: "hx-on--prompt";
+        readonly onPushedIntoHistory: "hx-on--pushed-into-history";
+        readonly onReplacedInHistory: "hx-on--replaced-in-history";
+        readonly onResponseError: "hx-on--response-error";
+        readonly onSendAbort: "hx-on--send-abort";
+        readonly onSendError: "hx-on--send-error";
+        readonly onSseError: "hx-on--sse-error";
+        readonly onSseOpen: "hx-on--sse-open";
+        readonly onSwapError: "hx-on--swap-error";
+        readonly onTargetError: "hx-on--target-error";
+        readonly onTimeout: "hx-on--timeout";
+        readonly onValidateUrl: "hx-on--validate-url";
+        readonly onValidationValidate: "hx-on--validation-validate";
+        readonly onValidationFailed: "hx-on--validation-failed";
+        readonly onValidationHalted: "hx-on--validation-halted";
+        readonly onXhrAbort: "hx-on--xhr-abort";
+        readonly onXhrLoadend: "hx-on--xhr-loadend";
+        readonly onXhrLoadstart: "hx-on--xhr-loadstart";
+        readonly onXhrProgress: "hx-on--xhr-progress";
+        readonly get: "hx-get";
+        readonly post: "hx-post";
+        readonly put: "hx-put";
+        readonly delete: "hx-delete";
+        readonly patch: "hx-patch";
+        readonly pushUrl: "hx-push-url";
+        readonly select: "hx-select";
+        readonly selectOob: "hx-select-oob";
+        readonly swap: "hx-swap";
+        readonly swapOob: "hx-swap-oob";
+        readonly target: "hx-target";
+        readonly trigger: "hx-trigger";
+        readonly vals: "hx-vals";
+        readonly boost: "hx-boost";
+        readonly confirm: "hx-confirm";
+        readonly disable: "hx-disable";
+        readonly disabledElt: "hx-disabled-elt";
+        readonly disinherit: "hx-disinherit";
+        readonly encoding: "hx-encoding";
+        readonly ext: "hx-ext";
+        readonly headers: "hx-headers";
+        readonly history: "hx-history";
+        readonly historyElt: "hx-history-elt";
+        readonly include: "hx-include";
+        readonly indicator: "hx-indicator";
+        readonly inherit: "hx-inherit";
+        readonly params: "hx-params";
+        readonly preserve: "hx-preserve";
+        readonly prompt: "hx-prompt";
+        readonly replaceUrl: "hx-replace-url";
+        readonly request: "hx-request";
+        readonly sync: "hx-sync";
+        readonly validate: "hx-validate";
+        readonly vars: "hx-vars";
+    };
+    readonly config: HtmxConfig;
+    readonly css: {
+        readonly added: "htmx-added";
+        readonly indicator: "htmx-indicator";
+        readonly request: "htmx-request";
+        readonly settling: "htmx-settling";
+        readonly swapping: "htmx-swapping";
+    };
+    readonly event: {
+        readonly abort: "htmx:abort";
+        readonly afterOnLoad: "htmx:afterOnLoad";
+        readonly afterProcessNode: "htmx:afterProcessNode";
+        readonly afterRequest: "htmx:afterRequest";
+        readonly afterSettle: "htmx:afterSettle";
+        readonly afterSwap: "htmx:afterSwap";
+        readonly beforeCleanupElement: "htmx:beforeCleanupElement";
+        readonly beforeOnLoad: "htmx:beforeOnLoad";
+        readonly beforeProcessNode: "htmx:beforeProcessNode";
+        readonly beforeRequest: "htmx:beforeRequest";
+        readonly beforeSwap: "htmx:beforeSwap";
+        readonly beforeSend: "htmx:beforeSend";
+        readonly beforeTransition: "htmx:beforeTransition";
+        readonly configRequest: "htmx:configRequest";
+        readonly confirm: "htmx:confirm";
+        readonly historyCacheError: "htmx:historyCacheError";
+        readonly historyCacheHit: "htmx:historyCacheHit";
+        readonly historyCacheMiss: "htmx:historyCacheMiss";
+        readonly historyCacheMissLoadError: "htmx:historyCacheMissLoadError";
+        readonly historyCacheMissLoad: "htmx:historyCacheMissLoad";
+        readonly historyRestore: "htmx:historyRestore";
+        readonly beforeHistorySave: "htmx:beforeHistorySave";
+        readonly load: "htmx:load";
+        readonly noSSESourceError: "htmx:noSSESourceError";
+        readonly onLoadError: "htmx:onLoadError";
+        readonly oobAfterSwap: "htmx:oobAfterSwap";
+        readonly oobBeforeSwap: "htmx:oobBeforeSwap";
+        readonly oobErrorNoTarget: "htmx:oobErrorNoTarget";
+        readonly prompt: "htmx:prompt";
+        readonly pushedIntoHistory: "htmx:pushedIntoHistory";
+        readonly replacedInHistory: "htmx:replacedInHistory";
+        readonly responseError: "htmx:responseError";
+        readonly sendAbort: "htmx:sendAbort";
+        readonly sendError: "htmx:sendError";
+        readonly sseError: "htmx:sseError";
+        readonly sseOpen: "htmx:sseOpen";
+        readonly swapError: "htmx:swapError";
+        readonly targetError: "htmx:targetError";
+        readonly timeout: "htmx:timeout";
+        readonly validateUrl: "htmx:validateUrl";
+        readonly validationValidate: "htmx:validation:validate";
+        readonly validationFailed: "htmx:validation:failed";
+        readonly validationHalted: "htmx:validation:halted";
+        readonly xhrAbort: "htmx:xhr:abort";
+        readonly xhrLoadend: "htmx:xhr:loadend";
+        readonly xhrLoadstart: "htmx:xhr:loadstart";
+        readonly xhrProgress: "htmx:xhr:progress";
+    };
+    readonly eventAttr: {
+        readonly onAbort: "hx-on--abort";
+        readonly onAfterOnLoad: "hx-on--after-on-load";
+        readonly onAfterProcessNode: "hx-on--after-process-node";
+        readonly onAfterRequest: "hx-on--after-request";
+        readonly onAfterSettle: "hx-on--after-settle";
+        readonly onAfterSwap: "hx-on--after-swap";
+        readonly onBeforeCleanupElement: "hx-on--before-cleanup-element";
+        readonly onBeforeOnLoad: "hx-on--before-on-load";
+        readonly onBeforeProcessNode: "hx-on--before-process-node";
+        readonly onBeforeRequest: "hx-on--before-request";
+        readonly onBeforeSwap: "hx-on--before-swap";
+        readonly onBeforeSend: "hx-on--before-send";
+        readonly onBeforeTransition: "hx-on--before-transition";
+        readonly onConfigRequest: "hx-on--config-request";
+        readonly onConfirm: "hx-on--confirm";
+        readonly onHistoryCacheError: "hx-on--history-cache-error";
+        readonly onHistoryCacheHit: "hx-on--history-cache-hit";
+        readonly onHistoryCacheMiss: "hx-on--history-cache-miss";
+        readonly onHistoryCacheMissLoadError: "hx-on--history-cache-miss-load-error";
+        readonly onHistoryCacheMissLoad: "hx-on--history-cache-miss-load";
+        readonly onHistoryRestore: "hx-on--history-restore";
+        readonly onBeforeHistorySave: "hx-on--before-history-save";
+        readonly onLoad: "hx-on--load";
+        readonly onNoSSESourceError: "hx-on--no-sse-source-error";
+        readonly onOnLoadError: "hx-on--on-load-error";
+        readonly onOobAfterSwap: "hx-on--oob-after-swap";
+        readonly onOobBeforeSwap: "hx-on--oob-before-swap";
+        readonly onOobErrorNoTarget: "hx-on--oob-error-no-target";
+        readonly onPrompt: "hx-on--prompt";
+        readonly onPushedIntoHistory: "hx-on--pushed-into-history";
+        readonly onReplacedInHistory: "hx-on--replaced-in-history";
+        readonly onResponseError: "hx-on--response-error";
+        readonly onSendAbort: "hx-on--send-abort";
+        readonly onSendError: "hx-on--send-error";
+        readonly onSseError: "hx-on--sse-error";
+        readonly onSseOpen: "hx-on--sse-open";
+        readonly onSwapError: "hx-on--swap-error";
+        readonly onTargetError: "hx-on--target-error";
+        readonly onTimeout: "hx-on--timeout";
+        readonly onValidateUrl: "hx-on--validate-url";
+        readonly onValidationValidate: "hx-on--validation-validate";
+        readonly onValidationFailed: "hx-on--validation-failed";
+        readonly onValidationHalted: "hx-on--validation-halted";
+        readonly onXhrAbort: "hx-on--xhr-abort";
+        readonly onXhrLoadend: "hx-on--xhr-loadend";
+        readonly onXhrLoadstart: "hx-on--xhr-loadstart";
+        readonly onXhrProgress: "hx-on--xhr-progress";
+    };
+    readonly ext: {
+        readonly headSupport: {
+            readonly name: "head-support";
+            readonly version: "2.0.5";
+            readonly npm: "htmx-ext-head-support";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-head-support@2.0.5";
+                readonly integrity: "sha384-cvMqHzjCJsOHgGuyB3sWXaUSv/Krm0BdzjuI1rtkjCbL1l1oHJx+cHyVRJhyuEz0";
+            }];
+        };
+        readonly htmx1Compat: {
+            readonly name: "htmx-1-compat";
+            readonly version: "2.0.2";
+            readonly npm: "htmx-ext-htmx-1-compat";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-htmx-1-compat@2.0.2";
+                readonly integrity: "sha384-lcvVWaNjF5zPPUeeWmC0OkJ2MLqoWLlkAabuGm+EuMSTfGo5WRyHrNaAp0cJr9Pg";
+            }];
+        };
+        readonly idiomorph: {
+            readonly name: "morph";
+            readonly version: "0.7.4";
+            readonly npm: "idiomorph";
+            readonly cdn: readonly [{
+                readonly url: "https://unpkg.com/idiomorph@0.7.4/dist/idiomorph-ext.min.js";
+                readonly integrity: "sha384-SsScJKzATF/w6suEEdLbgYGsYFLzeKfOA6PY+/C5ZPxOSuA+ARquqtz/BZz9JWU8";
+            }];
+        };
+        readonly preload: {
+            readonly name: "preload";
+            readonly version: "2.1.2";
+            readonly npm: "htmx-ext-preload";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-preload@2.1.2";
+                readonly integrity: "sha384-PRIcY6hH1Y5784C76/Y8SqLyTanY9rnI3B8F3+hKZFNED55hsEqMJyqWhp95lgfk";
+            }];
+        };
+        readonly responseTargets: {
+            readonly name: "response-targets";
+            readonly version: "2.0.4";
+            readonly npm: "htmx-ext-response-targets";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-response-targets@2.0.4";
+                readonly integrity: "sha384-T41oglUPvXLGBVyRdZsVRxNWnOOqCynaPubjUVjxhsjFTKrFJGEMm3/0KGmNQ+Pg";
+            }];
+        };
+        readonly sse: {
+            readonly name: "sse";
+            readonly version: "2.2.4";
+            readonly npm: "htmx-ext-sse";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-sse@2.2.4";
+                readonly integrity: "sha384-A986SAtodyH8eg8x8irJnYUk7i9inVQqYigD6qZ9evobksGNIXfeFvDwLSHcp31N";
+            }];
+        };
+        readonly ws: {
+            readonly name: "ws";
+            readonly version: "2.0.4";
+            readonly npm: "htmx-ext-ws";
+            readonly cdn: readonly [{
+                readonly url: "https://cdn.jsdelivr.net/npm/htmx-ext-ws@2.0.4";
+                readonly integrity: "sha384-1RwI/nvUSrMRuNj7hX1+27J8XDdCoSLf0EjEyF69nacuWyiJYoQ/j39RT1mSnd2G";
+            }];
+        };
+    };
+    readonly method: {
+        readonly GET: "hx-get";
+        readonly POST: "hx-post";
+        readonly PUT: "hx-put";
+        readonly DELETE: "hx-delete";
+        readonly PATCH: "hx-patch";
+        readonly get: "hx-get";
+        readonly post: "hx-post";
+        readonly put: "hx-put";
+        readonly delete: "hx-delete";
+        readonly patch: "hx-patch";
+    };
+    readonly res: {
+        readonly location: "HX-Location";
+        readonly pushUrl: "HX-Push-URL";
+        readonly redirect: "HX-Redirect";
+        readonly refresh: "HX-Refresh";
+        readonly replaceUrl: "HX-Replace-URL";
+        readonly reswap: "HX-Reswap";
+        readonly retarget: "HX-Retarget";
+        readonly reselect: "HX-Reselect";
+        readonly trigger: "HX-Trigger";
+        readonly triggerAfterSettle: "HX-Trigger-After-Settle";
+        readonly triggerAfterSwap: "HX-Trigger-After-Swap";
+    };
+    readonly req: {
+        readonly boosted: "HX-Boosted";
+        readonly currentUrl: "HX-Current-URL";
+        readonly historyRestoreRequest: "HX-History-Restore-Request";
+        readonly prompt: "HX-Prompt";
+        readonly request: "HX-Request";
+        readonly target: "HX-Target";
+        readonly triggerName: "HX-Trigger-Name";
+        readonly trigger: "HX-Trigger";
+    };
+    readonly swap: {
+        readonly innerHTML: "innerHTML";
+        readonly outerHTML: "outerHTML";
+        readonly textContent: "textContent";
+        readonly beforeBegin: "beforebegin";
+        readonly afterBegin: "afterbegin";
+        readonly beforeEnd: "beforeend";
+        readonly afterEnd: "afterend";
+        readonly delete: "delete";
+        readonly none: "none";
+    };
+    readonly sync: {
+        readonly drop: "drop";
+        readonly abort: "abort";
+        readonly replace: "replace";
+        readonly queue: "queue";
+        readonly queueAll: "queue all";
+        readonly queueFirst: "queue first";
+        readonly queueLast: "queue last";
+    };
+};
+
+/** @see https://htmx.org/reference/#attributes */
+type HtmxAttribute = (typeof htmx.attr)[keyof typeof htmx.attr];
+/** @see https://htmx.org/reference/#classes */
+type HtmxClass = (typeof htmx.css)[keyof typeof htmx.css];
+/** @see https://htmx.org/reference/#events */
+type HtmxEventName = (typeof htmx.event)[keyof typeof htmx.event];
+/**
+ * @see https://htmx.org/reference/#events
+ * @see https://htmx.org/attributes/hx-on/
+ */
+type HtmxEventAttribute = (typeof htmx.eventAttr)[keyof typeof htmx.eventAttr] | `hx-on--${string}` | `hx-on-${string}`;
+interface HtmxExtensionMetadata {
+    name: string;
+    version: string;
+    npm?: string;
+    cdn?: Array<{
+        url: string;
+        integrity?: string;
+    }>;
+}
+type HtmxDefaultExtension = (typeof htmx.ext)[keyof typeof htmx.ext]['name'];
+/**
+ * @see https://htmx.org/docs/#ajax
+ * @see https://htmx.org/reference/#attributes
+ */
+type HtmxHttpMethod = keyof typeof htmx.method;
+/**
+ * @see https://htmx.org/docs/#ajax
+ * @see https://htmx.org/reference/#attributes
+ */
+type HtmxMethodAttribute = (typeof htmx.method)[keyof typeof htmx.method];
+type HtmxRequestHeader = (typeof htmx.req)[keyof typeof htmx.req];
+type HtmxResponseHeader = (typeof htmx.res)[keyof typeof htmx.res];
+type HtmxSwapStyle = (typeof htmx.swap)[keyof typeof htmx.swap];
+type HtmxSyncStrategy = (typeof htmx.sync)[keyof typeof htmx.sync];
+
+interface HtmxPathInfo {
+    /**
+     * The original request path specified for the HTMX request.
+     */
+    requestPath: string;
+    /**
+     * The final request path after any server-side redirections or URL rewrites.
+     */
+    finalRequestPath: string;
+    /**
+     * The path extracted from the server response, or `null` if none was provided.
+     */
+    responsePath: string | null;
+    /**
+     * The URL fragment (anchor) associated with the request.
+     */
+    anchor: string;
+}
+
+interface HtmxElementValidationError {
+    elt: Element;
+    message: string;
+    validity: ValidityState;
+}
+
+type HtmxHttpVerb = HttpVerb;
+
+interface HtmxRequestConfig {
+    /**
+     * Indicates if the request was boosted via `hx-boost`.
+     */
+    boosted: boolean;
+    /**
+     * The element that initiated the HTMX request.
+     */
+    elt: Element;
+    /**
+     * Validation errors associated with the target element.
+     */
+    errors: HtmxElementValidationError[];
+    /**
+     * FormData object assembled for the request.
+     */
+    formData: FormData;
+    /**
+     * HTTP headers to include with the request.
+     */
+    headers: Record<string, string>;
+    /**
+     * Key/value pairs representing entries in `formData`.
+     */
+    parameters: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /**
+     * URL or path used for the HTMX request.
+     */
+    path: string;
+    /**
+     * Element into which the response content will be swapped.
+     */
+    target: Element;
+    /**
+     * Maximum time in milliseconds before the request times out.
+     */
+    timeout: number;
+    /**
+     * Original DOM event that triggered the HTMX request.
+     */
+    triggeringEvent: Event;
+    /**
+     * Unfiltered FormData before any HTMX processing.
+     */
+    unfilteredFormData: FormData;
+    /**
+     * Key/value pairs representing entries in `unfilteredFormData`.
+     */
+    unfilteredParameters: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /**
+     * Whether to include parameters in the URL instead of the request body.
+     */
+    useUrlParams: boolean;
+    /**
+     * HTTP method to use for the request (e.g.\ `"GET"`, `"POST"`).
+     */
+    verb: HtmxHttpVerb;
+    /**
+     * Whether to include credentials (cookies, authorization headers) with the request.
+     */
+    withCredentials: boolean;
+}
+
+/**
+ * Callback invoked during the HTMX AJAX lifecycle.
+ */
+type HtmxAjaxHandler = (elt: Element, responseInfo: {
+    /**
+     * The underlying `XMLHttpRequest` instance.
+     */
+    xhr: XMLHttpRequest;
+    /**
+     * Element into which the response content will be swapped.
+     */
+    target: Element;
+    /**
+     * Configuration used for the HTMX request.
+     */
+    requestConfig: HtmxRequestConfig;
+    /**
+     * Additional AJAX-specific options and callbacks.
+     */
+    etc: HtmxAjaxEtc;
+    /**
+     * Indicates whether the request was boosted via `hx-boost`.
+     */
+    boosted: boolean;
+    /**
+     * CSS selector used for swapping content.
+     */
+    select: string;
+    /**
+     * Parsed path information for the request URL.
+     */
+    pathInfo: HtmxPathInfo;
+    /**
+     * True if the request failed.
+     */
+    failed?: boolean;
+    /**
+     * True if the request completed successfully.
+     */
+    successful?: boolean;
+    /**
+     * Whether to retain CSS indicators after the swap.
+     */
+    keepIndicators?: boolean;
+}) => any;
+
+interface HtmxAjaxEtc {
+    /**
+     * When true, returns a Promise that resolves with the AJAX response.
+     */
+    returnPromise?: boolean;
+    /**
+     * Custom handler invoked during the AJAX request lifecycle.
+     */
+    handler?: HtmxAjaxHandler;
+    /**
+     * CSS selector used to find the element(s) to swap content into.
+     */
+    select?: string | null;
+    /**
+     * Overrides the default target element for content swapping.
+     */
+    targetOverride?: Element;
+    /**
+     * Overrides the default swap strategy (e.g., "innerHTML", "outerHTML").
+     */
+    swapOverride?: HtmxSwapStyle;
+    /**
+     * Additional HTTP headers to include with the request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * FormData instance containing key/value pairs to send with the request.
+     */
+    values?: FormData;
+    /**
+     * Indicates whether to include credentials (cookies, authorization headers) in the request.
+     */
+    credentials?: boolean;
+    /**
+     * Maximum time in milliseconds before the request times out.
+     */
+    timeout?: number;
+}
+
+interface HtmxCacheItem {
+    /**
+     * The request URL used as the cache key.
+     */
+    url: string;
+    /**
+     * The cached HTML content or response text associated with the URL.
+     */
+    content: string;
+}
+
+type HtmxResponseHandlingConfig = HtmxResponseHandlingConfig$1;
+
+/**
+ * @see https://htmx.org/reference/#config
+ */
+type HtmxConfig = {
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    addedClass: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    allowEval: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    allowNestedOobSwaps: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    allowScriptTags: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    attributesToSettle: string[];
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    defaultFocusScroll: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    defaultSettleDelay: number;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    defaultSwapDelay: number;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    defaultSwapStyle: HtmxSwapStyle | (string & {});
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    disableInheritance: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    disableSelector: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    getCacheBusterParam: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    globalViewTransitions: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    historyCacheSize: number;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    historyEnabled: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    historyRestoreAsHxRequest: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    ignoreTitle: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    includeIndicatorStyles: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    indicatorClass: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    inlineScriptNonce: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    inlineStyleNonce: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    methodsThatUseUrlParams: HtmxHttpVerb[];
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    refreshOnHistoryMiss: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    requestClass: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    responseHandling: HtmxResponseHandlingConfig[];
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    scrollBehavior: 'auto' | 'instant' | 'smooth';
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    scrollIntoViewOnBoost: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    selfRequestsOnly: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    settlingClass: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    swappingClass: string;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    timeout: number;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    triggerSpecsCache: any | null;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    withCredentials: boolean;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    wsBinaryType: BinaryType;
+    /**
+     * @see https://htmx.org/reference/#config
+     */
+    wsReconnectDelay: 'full-jitter' | ((retryCount: number) => number);
+};
+
+type HtmxIssueRequest = (skipConfirmation?: boolean) => void;
+
+interface HtmxSwapSpec {
+    /**
+     * Vertical scroll offset to apply after the swap completes.
+     */
+    scroll: number;
+    /**
+     * Time in milliseconds to wait before initiating the swap’s settle phase.
+     */
+    settleDelay: number;
+    /**
+     * Time in milliseconds to wait before performing the actual content swap.
+     */
+    swapDelay: number;
+    /**
+     * Strategy for swapping content (e.g., “innerHTML”, “outerHTML”).
+     */
+    swapStyle: HtmxSwapStyle;
+}
+
+interface HtmxEventDetail {
+    /**
+     * Indicates if the request was boosted via `hx-boost`.
+     */
+    boosted?: boolean | undefined;
+    /**
+     * The content element to be swapped in.
+     */
+    content?: Element;
+    /**
+     * The element that triggered the event.
+     */
+    elt?: Element;
+    /**
+     * Validation errors for the target element.
+     */
+    errors?: HtmxElementValidationError[];
+    /**
+     * Additional AJAX-related information.
+     */
+    etc?: HtmxAjaxEtc;
+    /**
+     * Error message returned by the server.
+     */
+    error?: string;
+    /**
+     * The original DOM event associated with this detail.
+     */
+    event?: Event;
+    /**
+     * Exception caught during request handling.
+     */
+    exception?: Error;
+    /**
+     * Whether the request failed.
+     */
+    failed?: boolean;
+    /**
+     * Collected form data for the request.
+     */
+    formData?: FormData;
+    /**
+     * Fragment element extracted from the response.
+     */
+    fragment?: Element;
+    /**
+     * Parsed response headers as key/value pairs.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Element used for history updates.
+     */
+    historyElt?: Element;
+    /**
+     * If true, update of document title is skipped.
+     */
+    ignoreTitle?: boolean | undefined;
+    /**
+     * True when the response status indicates an error.
+     */
+    isError?: boolean;
+    /**
+     * Details for issuing follow-up requests.
+     */
+    issueRequest?: HtmxIssueRequest;
+    /**
+     * Cached item associated with the request.
+     */
+    item?: HtmxCacheItem;
+    /**
+     * Retain CSS indicators after swap.
+     */
+    keepIndicators?: boolean;
+    /**
+     * Indicates if the total size is computable in progress events.
+     */
+    lengthComputable?: boolean;
+    /**
+     * Number of bytes loaded in progress events.
+     */
+    loaded?: number;
+    /**
+     * Message returned from the server.
+     */
+    message?: string;
+    /**
+     * Proxy for `formData` as a key/value map.
+     */
+    parameters?: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /**
+     * Request path used.
+     */
+    path?: string;
+    /**
+     * Parsed information about the request path.
+     */
+    pathInfo?: HtmxPathInfo;
+    /**
+     * Prompt text displayed to the user.
+     */
+    prompt?: string;
+    /**
+     * User response for confirmation or prompt dialogs.
+     */
+    question?: string | null;
+    /**
+     * Raw response text from the server.
+     */
+    response?: string;
+    /**
+     * Configuration used for the request.
+     */
+    requestConfig?: HtmxRequestConfig;
+    /**
+     * True if the response came from the same host.
+     */
+    sameHost?: boolean;
+    /**
+     * CSS selector used for swapping content.
+     */
+    select?: string | null;
+    /**
+     * Overrides the default swap selector.
+     */
+    selectOverride?: string | null;
+    /**
+     * Unparsed server response string.
+     */
+    serverResponse?: string;
+    /**
+     * Indicates whether a swap should occur.
+     */
+    shouldSwap?: boolean;
+    /**
+     * Associated `EventSource` for server-sent events.
+     */
+    source?: EventSource;
+    /**
+     * True if the request completed successfully.
+     */
+    successful?: boolean;
+    /**
+     * Overrides the swap style (e.g., `innerHTML`, `outerHTML`).
+     */
+    swapOverride?: HtmxSwapStyle | null;
+    /**
+     * Parsed specification for swapping.
+     */
+    swapSpec?: HtmxSwapSpec;
+    /**
+     * Target element for content swap.
+     */
+    target?: Element;
+    /**
+     * Timeout value for the request in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Total bytes expected in progress events.
+     */
+    total?: number;
+    /**
+     * The original event that triggered this HTMX event.
+     */
+    triggeringEvent?: Event;
+    /**
+     * Unfiltered form data before any modifications.
+     */
+    unfilteredFormData?: FormData;
+    /**
+     * Proxy for `unfilteredFormData` as a key/value map.
+     */
+    unfilteredParameters?: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /**
+     * Full URL used for the request.
+     */
+    url?: URL;
+    /**
+     * Whether URL parameters should be used instead of body.
+     */
+    useUrlParams?: boolean;
+    /**
+     * Validity state of the form element.
+     */
+    validity?: ValidityState;
+    /**
+     * HTTP method used for the request.
+     */
+    verb?: HtmxHttpVerb;
+    /**
+     * Whether credentials are included in the request.
+     */
+    withCredentials?: boolean;
+    /**
+     * Underlying `XMLHttpRequest` object.
+     */
+    xhr?: XMLHttpRequest;
+}
+
+interface HtmxDomEvent extends Event {
+    detail: HtmxEventDetail;
+    type: HtmxEventName;
+}
+
+interface DomObjects {
+    document: Document;
+    htmx: HtmxInstance;
+    window: Window;
+}
+
+interface HtmxEventProps<TDom extends object = object> {
+    onAbort?: (args: {
+        event: HtmxAbortEvent;
+    } & DomObjects & TDom) => void;
+    onAfterOnLoad?: (args: {
+        event: HtmxAfterOnLoadEvent;
+    } & DomObjects & TDom) => void;
+    onAfterProcessNode?: (args: {
+        event: HtmxAfterProcessNodeEvent;
+    } & DomObjects & TDom) => void;
+    onAfterRequest?: (args: {
+        event: HtmxAfterRequestEvent;
+    } & DomObjects & TDom) => void;
+    onAfterSettle?: (args: {
+        event: HtmxAfterSettleEvent;
+    } & DomObjects & TDom) => void;
+    onAfterSwap?: (args: {
+        event: HtmxAfterSwapEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeCleanupElement?: (args: {
+        event: HtmxBeforeCleanupElementEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeOnLoad?: (args: {
+        event: HtmxBeforeOnLoadEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeProcessNode?: (args: {
+        event: HtmxBeforeProcessNodeEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeRequest?: (args: {
+        event: HtmxBeforeRequestEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeSwap?: (args: {
+        event: HtmxBeforeSwapEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeSend?: (args: {
+        event: HtmxBeforeSendEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeTransition?: (args: {
+        event: HtmxBeforeTransitionEvent;
+    } & DomObjects & TDom) => void;
+    onConfigRequest?: (args: {
+        event: HtmxConfigRequestEvent;
+    } & DomObjects & TDom) => void;
+    onConfirm?: (args: {
+        event: HtmxConfirmEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryCacheError?: (args: {
+        event: HtmxHistoryCacheErrorEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryCacheHit?: (args: {
+        event: HtmxHistoryCacheHitEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryCacheMiss?: (args: {
+        event: HtmxHistoryCacheMissEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryCacheMissLoadError?: (args: {
+        event: HtmxHistoryCacheMissLoadErrorEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryCacheMissLoad?: (args: {
+        event: HtmxHistoryCacheMissLoadEvent;
+    } & DomObjects & TDom) => void;
+    onHistoryRestore?: (args: {
+        event: HtmxHistoryRestoreEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeHistorySave?: (args: {
+        event: HtmxBeforeHistorySaveEvent;
+    } & DomObjects & TDom) => void;
+    onLoad?: (args: {
+        event: HtmxLoadEvent;
+    } & DomObjects & TDom) => void;
+    onNoSSESourceError?: (args: {
+        event: HtmxNoSseSourceErrorEvent;
+    } & DomObjects & TDom) => void;
+    onOnLoadError?: (args: {
+        event: HtmxOnLoadErrorEvent;
+    } & DomObjects & TDom) => void;
+    onOobAfterSwap?: (args: {
+        event: HtmxOobAfterSwapEvent;
+    } & DomObjects & TDom) => void;
+    onOobBeforeSwap?: (args: {
+        event: HtmxOobBeforeSwapEvent;
+    } & DomObjects & TDom) => void;
+    onOobErrorNoTarget?: (args: {
+        event: HtmxOobErrorNoTargetEvent;
+    } & DomObjects & TDom) => void;
+    onPrompt?: (args: {
+        event: HtmxPromptEvent;
+    } & DomObjects & TDom) => void;
+    onPushedIntoHistory?: (args: {
+        event: HtmxPushedIntoHistoryEvent;
+    } & DomObjects & TDom) => void;
+    onReplacedInHistory?: (args: {
+        event: HtmxReplacedInHistoryEvent;
+    } & DomObjects & TDom) => void;
+    onResponseError?: (args: {
+        event: HtmxResponseErrorEvent;
+    } & DomObjects & TDom) => void;
+    onSendAbort?: (args: {
+        event: HtmxSendAbortEvent;
+    } & DomObjects & TDom) => void;
+    onSendError?: (args: {
+        event: HtmxSendErrorEvent;
+    } & DomObjects & TDom) => void;
+    onSseError?: (args: {
+        event: HtmxSseErrorEvent;
+    } & DomObjects & TDom) => void;
+    onSseOpen?: (args: {
+        event: HtmxSseOpenEvent;
+    } & DomObjects & TDom) => void;
+    onSwapError?: (args: {
+        event: HtmxSwapErrorEvent;
+    } & DomObjects & TDom) => void;
+    onTargetError?: (args: {
+        event: HtmxTargetErrorEvent;
+    } & DomObjects & TDom) => void;
+    onTimeout?: (args: {
+        event: HtmxTimeoutEvent;
+    } & DomObjects & TDom) => void;
+    onValidateUrl?: (args: {
+        event: HtmxValidateUrlEvent;
+    } & DomObjects & TDom) => void;
+    onValidationValidate?: (args: {
+        event: HtmxValidationValidateEvent;
+    } & DomObjects & TDom) => void;
+    onValidationFailed?: (args: {
+        event: HtmxValidationFailedEvent;
+    } & DomObjects & TDom) => void;
+    onValidationHalted?: (args: {
+        event: HtmxValidationHaltedEvent;
+    } & DomObjects & TDom) => void;
+    onXhrAbort?: (args: {
+        event: HtmxXhrAbortEvent;
+    } & DomObjects & TDom) => void;
+    onXhrLoadend?: (args: {
+        event: HtmxXhrLoadendEvent;
+    } & DomObjects & TDom) => void;
+    onXhrLoadstart?: (args: {
+        event: HtmxXhrLoadstartEvent;
+    } & DomObjects & TDom) => void;
+    onXhrProgress?: (args: {
+        event: HtmxXhrProgressEvent;
+    } & DomObjects & TDom) => void;
+}
+
+type HtmxEvent = Parameters<Exclude<HtmxEventProps[keyof HtmxEventProps], undefined>>[0];
+
+type HtmxSettleInfo = HtmxSettleInfo$1;
+
+interface HtmxExtension<T extends CustomEvent = CustomEvent & HtmxEvent> {
+    /**
+     * Initializes the extension with the HTMX API.
+     */
+    init?: (api: any) => void;
+    /**
+     * Intercepts HTMX events dispatched on elements.
+     * Return `false` to prevent default HTMX handling.
+     */
+    onEvent?: (name: string, event: T) => boolean;
+    /**
+     * Transforms the raw response text before swapping into the DOM.
+     */
+    transformResponse?: (text: string, xhr: XMLHttpRequest, elt: Element) => string;
+    /**
+     * Determines if a swap style should be treated as inline insertion.
+     */
+    isInlineSwap?: (swapStyle: HtmxSwapStyle) => boolean;
+    /**
+     * Custom handler for swapping content into the target node.
+     */
+    handleSwap?: (swapStyle: HtmxSwapStyle, target: Node, fragment: Node, settleInfo: HtmxSettleInfo) => boolean | Node[];
+    /**
+     * Encodes request parameters before sending via `XMLHttpRequest`.
+     */
+    encodeParameters?: (xhr: XMLHttpRequest, parameters: FormData, elt: Node) => any | string | null;
+    /**
+     * Provides additional selectors for HTMX to initialize.
+     */
+    getSelectors?: () => string[] | null;
+}
+
+type Duration = `${number}${'m' | 's' | 'ms'}`;
+
+interface HtmxInstance {
+    _: (str: string) => any;
+    /**
+     * Adds a class to the given element.
+     */
+    addClass: (elt: Element | string, clazz: string, delay?: Duration) => void;
+    /**
+     * Issues an htmx-style ajax request.
+     */
+    ajax: (verb: HttpVerb, path: string, context: Element | string | HtmxAjaxHelperContext) => Promise<void>;
+    /**
+     * Finds the closest parent to the given element matching the selector.
+     */
+    closest: (elt: Element | string, selector: string) => Element | null;
+    /**
+     * A property that holds the current htmx config object.
+     */
+    config: HtmxConfig;
+    /**
+     * A property holding the function to create SSE EventSource objects for htmx,
+     */
+    createEventSource: (url: string) => EventSource;
+    /**
+     * A property holding the function to create WebSocket objects for htmx.
+     */
+    createWebSocket: (url: string) => WebSocket;
+    /**
+     * 	Defines an htmx [extension](https://htmx.org/extensions).
+     */
+    defineExtension: (name: string, extension: Partial<HtmxExtension$1>) => void;
+    /**
+     * Finds a single element matching the selector.
+     */
+    find: (eltOrSelector: ParentNode | string, selector?: string) => Element | null;
+    /**
+     * Finds all elements matching a given selector.
+     */
+    findAll: {
+        (): NodeListOf<Element>;
+        (eltOrSelector: ParentNode | string, selector?: string): NodeListOf<Element>;
+    };
+    /**
+     * A property that holds the current window location (URL).
+     */
+    location: Location;
+    /**
+     * Installs a logger that will log all htmx events.
+     */
+    logAll: () => void;
+    /**
+     * Removes the existing logger.
+     */
+    logNone: () => void;
+    /**
+     *  A property set to the current logger (default is `null`).
+     */
+    logger: any;
+    /**
+     * Removes an event listener from the given element.
+     */
+    off: (arg1: EventTarget | string, arg2: string | EventListener, arg3?: EventListener) => EventListener;
+    /**
+     * Creates an event listener on the given element, returning it.
+     */
+    on: (arg1: EventTarget | string, arg2: string | EventListener, arg3?: EventListener | any | boolean, arg4?: any | boolean) => EventListener;
+    /**
+     * Adds a callback handler for the `htmx:load` event.
+     */
+    onLoad: (callback: (elt: Node) => void) => EventListener;
+    /**
+     * Parses an interval declaration into a millisecond value.
+     */
+    parseInterval: (str: string) => number | undefined;
+    /**
+     * Processes the given element and its children, hooking up any htmx behavior.
+     */
+    process: (elt: Element | string) => void;
+    /**
+     * Removes the given element.
+     */
+    remove: (elt: Node, delay?: Duration) => void;
+    /**
+     * Removes a class from the given element.
+     */
+    removeClass: (node: Node | string, clazz: string, delay?: Duration) => void;
+    /**
+     * Removes an htmx [extension](https://htmx.org/extensions).
+     */
+    removeExtension: (name: string) => void;
+    /**
+     * Performs swapping (and settling) of HTML content.
+     */
+    swap: (target: string | Element, content: string, swapSpec: HtmxSwapSpecification, swapOptions?: SwapOptions) => void;
+    /**
+     * Takes a class from other elements for the given element.
+     */
+    takeClass: (elt: Node | string, clazz: string) => void;
+    /**
+     * 	Toggles a class from the given element.
+     */
+    toggleClass: (elt: Element | string, clazz: string) => void;
+    /**
+     * Triggers an event on an element.
+     */
+    trigger: (elt: EventTarget | string, eventName: string, detail?: any | undefined) => boolean;
+    /**
+     * Returns the input values associated with the given element.
+     */
+    values: (elt: Element, type: HttpVerb) => any;
+    /**
+     * Current htmx version.
+     */
+    version: string;
+}
+
+type Detail<TProperties extends keyof HtmxEventDetail> = Pick<Required<HtmxEventDetail>, TProperties> & {
+    [K in Exclude<keyof HtmxEventDetail, TProperties>]?: never;
+};
+
+type HtmxAbortEventProperties = 'boosted' | 'elt' | 'error' | 'etc' | 'pathInfo' | 'requestConfig' | 'select' | 'target' | 'xhr';
+interface HtmxAbortEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAbortEventProperties>;
+    type: 'htmx:abort';
+}
+
+type HtmxAfterOnLoadEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxAfterOnLoadEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAfterOnLoadEventProperties>;
+    type: 'htmx:afterOnLoad';
+}
+
+type HtmxAfterProcessNodeEventProperties = 'elt';
+interface HtmxAfterProcessNodeEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAfterProcessNodeEventProperties>;
+    type: 'htmx:afterProcessNode';
+}
+
+type HtmxAfterRequestEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxAfterRequestEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAfterRequestEventProperties>;
+    type: 'htmx:afterRequest';
+}
+
+type HtmxAfterSettleEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxAfterSettleEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAfterSettleEventProperties>;
+    type: 'htmx:afterSettle';
+}
+
+type HtmxAfterSwapEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxAfterSwapEvent extends HtmxDomEvent {
+    detail: Detail<HtmxAfterSwapEventProperties>;
+    type: 'htmx:afterSwap';
+}
+
+type HtmxBeforeCleanupElementEventProperties = 'elt';
+interface HtmxBeforeCleanupElementEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeCleanupElementEventProperties>;
+    type: 'htmx:beforeCleanupElement';
+}
+
+type HtmxBeforeHistorySaveEventProperties = 'elt' | 'historyElt' | 'path';
+interface HtmxBeforeHistorySaveEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeHistorySaveEventProperties>;
+    type: 'htmx:beforeHistorySave';
+}
+
+type HtmxBeforeOnLoadEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxBeforeOnLoadEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeOnLoadEventProperties>;
+    type: 'htmx:beforeOnLoad';
+}
+
+type HtmxBeforeProcessNodeEventProperties = 'elt';
+interface HtmxBeforeProcessNodeEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeProcessNodeEventProperties>;
+    type: 'htmx:beforeProcessNode';
+}
+
+type HtmxBeforeRequestEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxBeforeRequestEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeRequestEventProperties>;
+    type: 'htmx:beforeRequest';
+}
+
+type HtmxBeforeSendEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxBeforeSendEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeSendEventProperties>;
+    type: 'htmx:beforeSend';
+}
+
+type HtmxBeforeSwapEventProperties = 'boosted' | 'elt' | 'etc' | 'ignoreTitle' | 'isError' | 'pathInfo' | 'requestConfig' | 'select' | 'selectOverride' | 'serverResponse' | 'shouldSwap' | 'swapOverride' | 'target' | 'xhr';
+interface HtmxBeforeSwapEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeSwapEventProperties>;
+    type: 'htmx:beforeSwap';
+}
+
+type HtmxBeforeTransitionEventProperties = 'boosted' | 'elt' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxBeforeTransitionEvent extends HtmxDomEvent {
+    detail: Detail<HtmxBeforeTransitionEventProperties>;
+    type: 'htmx:beforeTransition';
+}
+
+type HtmxConfigRequestEventProperties = 'boosted' | 'elt' | 'errors' | 'formData' | 'headers' | 'parameters' | 'path' | 'target' | 'timeout' | 'triggeringEvent' | 'unfilteredFormData' | 'unfilteredParameters' | 'useUrlParams' | 'verb' | 'withCredentials';
+interface HtmxConfigRequestEvent extends HtmxDomEvent {
+    detail: Detail<HtmxConfigRequestEventProperties>;
+    type: 'htmx:configRequest';
+}
+
+type HtmxConfirmEventProperties = 'elt' | 'etc' | 'issueRequest' | 'path' | 'question' | 'target' | 'triggeringEvent' | 'verb';
+interface HtmxConfirmEvent extends HtmxDomEvent {
+    detail: Detail<HtmxConfirmEventProperties>;
+    type: 'htmx:confirm';
+}
+
+type HtmxHistoryCacheErrorEventProperties = 'error' | 'path' | 'target';
+interface HtmxHistoryCacheErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryCacheErrorEventProperties>;
+    type: 'htmx:historyCacheError';
+}
+
+type HtmxHistoryCacheHitEventProperties = 'item' | 'target';
+interface HtmxHistoryCacheHitEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryCacheHitEventProperties>;
+    type: 'htmx:historyCacheHit';
+}
+
+type HtmxHistoryCacheMissEventProperties = 'path' | 'target';
+interface HtmxHistoryCacheMissEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryCacheMissEventProperties>;
+    type: 'htmx:historyCacheMiss';
+}
+
+type HtmxHistoryCacheMissLoadErrorEventProperties = 'path' | 'target' | 'xhr';
+interface HtmxHistoryCacheMissLoadErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryCacheMissLoadErrorEventProperties>;
+    type: 'htmx:historyCacheMissLoadError';
+}
+
+type HtmxHistoryCacheMissLoadEventProperties = 'historyElt' | 'path' | 'response' | 'swapSpec' | 'xhr';
+interface HtmxHistoryCacheMissLoadEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryCacheMissLoadEventProperties>;
+    type: 'htmx:historyCacheMissLoad';
+}
+
+type HtmxHistoryRestoreEventProperties = 'elt' | 'historyElt' | 'item' | 'path' | 'swapSpec';
+interface HtmxHistoryRestoreEvent extends HtmxDomEvent {
+    detail: Detail<HtmxHistoryRestoreEventProperties>;
+    type: 'htmx:historyRestore';
+}
+
+type HtmxLoadEventProperties = 'elt';
+interface HtmxLoadEvent extends HtmxDomEvent {
+    detail: Detail<HtmxLoadEventProperties>;
+    type: 'htmx:load';
+}
+
+type HtmxNoSseSourceErrorEventProperties = 'error' | 'source';
+interface HtmxNoSseSourceErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxNoSseSourceErrorEventProperties>;
+    type: 'htmx:noSSESourceError';
+}
+
+type HtmxOnLoadErrorEventProperties = 'elt' | 'error' | 'exception' | 'pathInfo' | 'requestConfig' | 'target' | 'xhr';
+interface HtmxOnLoadErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxOnLoadErrorEventProperties>;
+    type: 'htmx:onLoadError';
+}
+
+type HtmxOobAfterSwapEventProperties = 'elt' | 'fragment' | 'shouldSwap' | 'target';
+interface HtmxOobAfterSwapEvent extends HtmxDomEvent {
+    detail: Detail<HtmxOobAfterSwapEventProperties>;
+    type: 'htmx:oobAfterSwap';
+}
+
+type HtmxOobBeforeSwapEventProperties = 'elt' | 'fragment' | 'shouldSwap' | 'target';
+interface HtmxOobBeforeSwapEvent extends HtmxDomEvent {
+    detail: Detail<HtmxOobBeforeSwapEventProperties>;
+    type: 'htmx:oobBeforeSwap';
+}
+
+type HtmxOobErrorNoTargetEventProperties = 'content' | 'elt' | 'error';
+interface HtmxOobErrorNoTargetEvent extends HtmxDomEvent {
+    detail: Detail<HtmxOobErrorNoTargetEventProperties>;
+    type: 'htmx:oobErrorNoTarget';
+}
+
+type HtmxPromptEventProperties = 'elt' | 'prompt' | 'target';
+interface HtmxPromptEvent extends HtmxDomEvent {
+    detail: Detail<HtmxPromptEventProperties>;
+    type: 'htmx:prompt';
+}
+
+type HtmxPushedIntoHistoryEventProperties = 'elt' | 'path';
+interface HtmxPushedIntoHistoryEvent extends HtmxDomEvent {
+    detail: Detail<HtmxPushedIntoHistoryEventProperties>;
+    type: 'htmx:pushedIntoHistory';
+}
+
+type HtmxReplacedInHistoryEventProperties = 'elt' | 'path';
+interface HtmxReplacedInHistoryEvent extends HtmxDomEvent {
+    detail: Detail<HtmxReplacedInHistoryEventProperties>;
+    type: 'htmx:replacedInHistory';
+}
+
+type HtmxResponseErrorEventProperties = 'boosted' | 'elt' | 'error' | 'etc' | 'failed' | 'pathInfo' | 'requestConfig' | 'select' | 'successful' | 'target' | 'xhr';
+interface HtmxResponseErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxResponseErrorEventProperties>;
+    type: 'htmx:responseError';
+}
+
+type HtmxSendAbortEventProperties = 'boosted' | 'elt' | 'error' | 'etc' | 'pathInfo' | 'requestConfig' | 'select' | 'target' | 'xhr';
+interface HtmxSendAbortEvent extends HtmxDomEvent {
+    detail: Detail<HtmxSendAbortEventProperties>;
+    type: 'htmx:sendAbort';
+}
+
+type HtmxSendErrorEventProperties = 'elt' | 'requestConfig' | 'target' | 'xhr';
+interface HtmxSendErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxSendErrorEventProperties>;
+    type: 'htmx:sendError';
+}
+
+type HtmxSseErrorEventProperties = 'error' | 'event' | 'source';
+interface HtmxSseErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxSseErrorEventProperties>;
+    type: 'htmx:sseError';
+}
+
+type HtmxSseOpenEventProperties = 'event' | 'source';
+interface HtmxSseOpenEvent extends HtmxDomEvent {
+    detail: Detail<HtmxSseOpenEventProperties>;
+    type: 'htmx:sseOpen';
+}
+
+type HtmxSwapErrorEventProperties = 'elt' | 'requestConfig' | 'target' | 'xhr';
+interface HtmxSwapErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxSwapErrorEventProperties>;
+    type: 'htmx:swapError';
+}
+
+type HtmxTargetErrorEventProperties = 'elt' | 'error' | 'target';
+interface HtmxTargetErrorEvent extends HtmxDomEvent {
+    detail: Detail<HtmxTargetErrorEventProperties>;
+    type: 'htmx:targetError';
+}
+
+type HtmxTimeoutEventProperties = 'elt' | 'requestConfig' | 'target' | 'xhr';
+interface HtmxTimeoutEvent extends HtmxDomEvent {
+    detail: Detail<HtmxTimeoutEventProperties>;
+    type: 'htmx:timeout';
+}
+
+type HtmxValidateUrlEventProperties = 'url' | 'sameHost';
+interface HtmxValidateUrlEvent extends HtmxDomEvent {
+    detail: Detail<HtmxValidateUrlEventProperties>;
+    type: 'htmx:validateUrl';
+}
+
+type HtmxValidationFailedEventProperties = 'elt' | 'message' | 'validity';
+interface HtmxValidationFailedEvent extends HtmxDomEvent {
+    detail: Detail<HtmxValidationFailedEventProperties>;
+    type: 'htmx:validation:failed';
+}
+
+type HtmxValidationHaltedEventProperties = 'boosted' | 'elt' | 'errors' | 'formData' | 'headers' | 'parameters' | 'path' | 'target' | 'timeout' | 'triggeringEvent' | 'unfilteredFormData' | 'unfilteredParameters' | 'useUrlParams' | 'verb' | 'withCredentials';
+interface HtmxValidationHaltedEvent extends HtmxDomEvent {
+    detail: Detail<HtmxValidationHaltedEventProperties>;
+    type: 'htmx:validation:halted';
+}
+
+type HtmxValidationValidateEventProperties = 'elt';
+interface HtmxValidationValidateEvent extends HtmxDomEvent {
+    detail: Detail<HtmxValidationValidateEventProperties>;
+    type: 'htmx:validation:validate';
+}
+
+type HtmxXhrAbortEventProperties = 'elt' | 'lengthComputable' | 'loaded' | 'total';
+interface HtmxXhrAbortEvent extends HtmxDomEvent {
+    detail: Detail<HtmxXhrAbortEventProperties>;
+    type: 'htmx:xhr:abort';
+}
+
+type HtmxXhrLoadendEventProperties = 'elt' | 'lengthComputable' | 'loaded' | 'total';
+interface HtmxXhrLoadendEvent extends HtmxDomEvent {
+    detail: Detail<HtmxXhrLoadendEventProperties>;
+    type: 'htmx:xhr:loadend';
+}
+
+type HtmxXhrLoadstartEventProperties = 'elt' | 'lengthComputable' | 'loaded' | 'total';
+interface HtmxXhrLoadstartEvent extends HtmxDomEvent {
+    detail: Detail<HtmxXhrLoadstartEventProperties>;
+    type: 'htmx:xhr:loadstart';
+}
+
+type HtmxXhrProgressEventProperties = 'elt' | 'lengthComputable' | 'loaded' | 'total';
+interface HtmxXhrProgressEvent extends HtmxDomEvent {
+    detail: Detail<HtmxXhrProgressEventProperties>;
+    type: 'htmx:xhr:progress';
+}
+
+interface Logger {
+    debug: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+}
+
+interface JhxConfig {
+    logger?: Logger;
+    stringify?: boolean;
+    escape?: boolean;
+}
+
+/**
+ * Properties for handling standard DOM events.
+ *
+ * Note: The `stringify` config property must be set to `true` since in-line
+ * DOM event handlers are stripped during rendering.
+ */
+interface CommonDomEventProps<TDom extends object = object> {
+    onClick?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onDoubleClick?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onContextMenu?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseDown?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseUp?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseMove?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseEnter?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseLeave?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseOver?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onMouseOut?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onAuxClick?: (args: {
+        event: MouseEvent;
+    } & DomObjects & TDom) => void;
+    onWheel?: (args: {
+        event: WheelEvent;
+    } & DomObjects & TDom) => void;
+    onKeyDown?: (args: {
+        event: KeyboardEvent;
+    } & DomObjects & TDom) => void;
+    onKeyPress?: (args: {
+        event: KeyboardEvent;
+    } & DomObjects & TDom) => void;
+    onKeyUp?: (args: {
+        event: KeyboardEvent;
+    } & DomObjects & TDom) => void;
+    onFocus?: (args: {
+        event: FocusEvent;
+    } & DomObjects & TDom) => void;
+    onBlur?: (args: {
+        event: FocusEvent;
+    } & DomObjects & TDom) => void;
+    onFocusIn?: (args: {
+        event: FocusEvent;
+    } & DomObjects & TDom) => void;
+    onFocusOut?: (args: {
+        event: FocusEvent;
+    } & DomObjects & TDom) => void;
+    onChange?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+    onInput?: (args: {
+        event: InputEvent;
+    } & DomObjects & TDom) => void;
+    onBeforeInput?: (args: {
+        event: InputEvent;
+    } & DomObjects & TDom) => void;
+    onSubmit?: (args: {
+        event: SubmitEvent;
+    } & DomObjects & TDom) => void;
+    onReset?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+    onInvalid?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+    onSelect?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+    onDrag?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDragStart?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDragEnd?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDragOver?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDragEnter?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDragLeave?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onDrop?: (args: {
+        event: DragEvent;
+    } & DomObjects & TDom) => void;
+    onTouchStart?: (args: {
+        event: TouchEvent;
+    } & DomObjects & TDom) => void;
+    onTouchMove?: (args: {
+        event: TouchEvent;
+    } & DomObjects & TDom) => void;
+    onTouchEnd?: (args: {
+        event: TouchEvent;
+    } & DomObjects & TDom) => void;
+    onTouchCancel?: (args: {
+        event: TouchEvent;
+    } & DomObjects & TDom) => void;
+    onPointerDown?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerMove?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerUp?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerCancel?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerEnter?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerLeave?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerOver?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onPointerOut?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onGotPointerCapture?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onLostPointerCapture?: (args: {
+        event: PointerEvent;
+    } & DomObjects & TDom) => void;
+    onCopy?: (args: {
+        event: ClipboardEvent;
+    } & DomObjects & TDom) => void;
+    onCut?: (args: {
+        event: ClipboardEvent;
+    } & DomObjects & TDom) => void;
+    onPaste?: (args: {
+        event: ClipboardEvent;
+    } & DomObjects & TDom) => void;
+    onCompositionStart?: (args: {
+        event: CompositionEvent;
+    } & DomObjects & TDom) => void;
+    onCompositionUpdate?: (args: {
+        event: CompositionEvent;
+    } & DomObjects & TDom) => void;
+    onCompositionEnd?: (args: {
+        event: CompositionEvent;
+    } & DomObjects & TDom) => void;
+    onAnimationStart?: (args: {
+        event: AnimationEvent;
+    } & DomObjects & TDom) => void;
+    onAnimationIteration?: (args: {
+        event: AnimationEvent;
+    } & DomObjects & TDom) => void;
+    onAnimationEnd?: (args: {
+        event: AnimationEvent;
+    } & DomObjects & TDom) => void;
+    onAnimationCancel?: (args: {
+        event: AnimationEvent;
+    } & DomObjects & TDom) => void;
+    onTransitionStart?: (args: {
+        event: TransitionEvent;
+    } & DomObjects & TDom) => void;
+    onTransitionEnd?: (args: {
+        event: TransitionEvent;
+    } & DomObjects & TDom) => void;
+    onTransitionRun?: (args: {
+        event: TransitionEvent;
+    } & DomObjects & TDom) => void;
+    onTransitionCancel?: (args: {
+        event: TransitionEvent;
+    } & DomObjects & TDom) => void;
+    onScroll?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+    onResize?: (args: {
+        event: UIEvent;
+    } & DomObjects & TDom) => void;
+    onToggle?: (args: {
+        event: Event;
+    } & DomObjects & TDom) => void;
+}
+type CustomDomEvent<TArgs> = {
+    event(args: TArgs): void;
+}['event'];
+type CustomDomEventProps<TDom extends object = object> = {
+    [K in `on${string}` as Exclude<K, keyof CommonDomEventProps<TDom> | keyof HtmxEventProps>]?: CustomDomEvent<{
+        event: Event;
+    } & DomObjects & TDom>;
+};
+type DomEventProps<TDom extends object = object> = CommonDomEventProps<TDom> & CustomDomEventProps<TDom>;
+
+type JhxAttribute = HtmxAttribute | HtmxEventAttribute | Lowercase<keyof DomEventProps> | Lowercase<Exclude<keyof DOMAttributes<any>, 'children' | 'dangerouslySetInnerHTML'>>;
+
+/**
+ * - If the value is an `object` or `string`, it is evaluated server-side at render time.
+ * - If the value is a `function`, it is evaluated client-side when triggered.
+ * @template TDom Type for additional parameters received from the DOM.
+ */
+type JhxEvaluableAttribute<TBaseDom extends object = object> = (<TDom extends TBaseDom | object = object>(dom: DomObjects & TDom) => Record<string, any> | object) | Record<string, any> | object | string;
+
+type JhxExtensionAttribute = Array<string | {
+    /** The name of the HTMX extension. */
+    name: HtmxDefaultExtension | (string & {});
+    /** Whether the extension will be ignored for the element (defaults to `false`). */
+    ignore?: boolean;
+}> | {
+    /** The name of the HTMX extension. */
+    name: HtmxDefaultExtension | (string & {});
+    /** Whether the extension will be ignored for the element (defaults to `false`). */
+    ignore?: boolean;
+} | HtmxDefaultExtension | (string & {});
+
+type JhxIndicatorAttribute = {
+    selector: string;
+    /** Defaults to `false`. */
+    closest?: boolean;
+    /** Defaults to `false`. */
+    inherit?: boolean;
+} | string;
+
+type JhxInheritAttribute = Array<HtmxAttribute | (string & {})> | HtmxAttribute | '*' | (string & {});
+
+type JhxParamsAttribute = {
+    include: string[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: string[];
+} | '*' | 'none' | (string & {});
+
+interface JhxRequestArgs {
+    timeout?: number;
+    credentials?: boolean;
+    noHeaders?: boolean;
+}
+/**
+ * - If the value is an `object` or `string`, it is evaluated server-side at render time.
+ * - If the value is a `function`, it is evaluated client-side when triggered.
+ */
+type JhxRequestAttribute<
+/** Type for additional parameters received from the DOM. */
+TDom extends object = object> = ((dom: DomObjects & TDom) => JhxRequestArgs) | JhxRequestArgs | string;
+
+type JhxSelectOobAttribute = Array<string | {
+    selector: string;
+    swap?: HtmxSwapStyle;
+}> | {
+    selector: string;
+    swap?: HtmxSwapStyle;
+} | string;
+
+type JhxSwapScroll = 'top' | 'bottom' | {
+    selector: string;
+    position: 'top' | 'bottom';
+} | {
+    window: true;
+    position: 'top' | 'bottom';
+};
+type JhxSwapShow = 'none' | JhxSwapScroll;
+type JhxSwapAttribute = (HtmxSwapStyle | (string & {})) | {
+    /** The swap style. */
+    style?: HtmxSwapStyle | (string & {});
+    /** The duration of time that htmx will wait to swap the content after receiving a response. */
+    swap?: Duration;
+    /** The duration of time that htmx will wait to settle after swapping. */
+    settle?: Duration;
+    /**
+     * Whether the [View Transitions API](https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API) will be used.
+     */
+    transition?: boolean;
+    /**
+     * Specifies the scrolling behavior after the swap.
+     * Can be `'top'`, `'bottom'`, or an object specifying a selector and position.
+     */
+    scroll?: JhxSwapScroll;
+    /**
+     * Specifies which element to show in the viewport after the swap.
+     * Can be `'top'`, `'bottom'`, `'none'`, or an object specifying a selector and position.
+     */
+    show?: JhxSwapShow;
+    /**
+     * Whether htmx will update the page title when the response contains a `<title>` element.
+     * Defaults to `false`.
+     */
+    ignoreTitle?: boolean;
+    /**
+     * Whether the `<input>` focus is maintained between requests. The `<input>` element must have an `id` attribute.
+     *
+     * Defaults to `false`.
+     */
+    focusScroll?: boolean;
+};
+
+type JhxSwapOobAttribute = {
+    swap: HtmxSwapStyle;
+    selector?: string;
+} | HtmxSwapStyle | boolean | (string & {});
+
+type JhxSyncAttribute = {
+    strategy: HtmxSyncStrategy;
+    tag: string;
+    closest?: boolean;
+} | {
+    strategy: HtmxSyncStrategy;
+    tag?: never;
+    closest?: never;
+} | string;
+
+type TargetAttribute = {
+    inherit?: never;
+    position?: 'closest' | 'next' | 'previous' | 'find';
+    selector: string;
+} | {
+    inherit?: never;
+    position: 'this' | 'next' | 'previous';
+    selector?: never;
+} | {
+    inherit: boolean;
+    position?: never;
+    selector?: never;
+};
+type JhxTargetAttribute = Array<TargetAttribute | string> | TargetAttribute | string;
+
+type JhxTriggerQueue = 'first' | 'last' | 'all' | 'none';
+type JhxTriggerFrom = {
+    selector: string;
+    op?: 'closest' | 'next' | 'previous' | 'find';
+} | {
+    selector?: never;
+    op: 'this' | 'document' | 'window';
+} | string;
+type ConditionalFunction = ConditionalFunction$1;
+interface JhxTriggerModifier {
+    changed?: boolean;
+    consume?: boolean;
+    delay?: Duration;
+    event?: string;
+    filter?: ConditionalFunction | string;
+    from?: JhxTriggerFrom;
+    once?: boolean;
+    queue?: JhxTriggerQueue;
+    target?: JhxTargetAttribute;
+    throttle?: Duration;
+}
+interface JhxTriggerAttribute_Standard extends JhxTriggerModifier {
+    trigger: 'load' | 'revealed' | (string & {});
+}
+interface JhxTriggerAttribute_Intersect extends JhxTriggerModifier {
+    trigger: 'intersect';
+    root?: string;
+    threshold?: number;
+}
+interface JhxTriggerAttribute_Poll extends JhxTriggerModifier {
+    poll: Duration;
+    trigger?: never;
+}
+type JhxTriggerAttribute = JhxTriggerAttribute_Standard | JhxTriggerAttribute_Intersect | JhxTriggerAttribute_Poll | (JhxTriggerAttribute_Standard | JhxTriggerAttribute_Intersect | JhxTriggerAttribute_Poll | string)[] | string;
+
+/** @template TDom Additional variables that are available in the DOM. */
+interface HtmxProps<TDom extends object = object> {
+    boost?: boolean;
+    confirm?: string;
+    delete?: string;
+    disable?: boolean;
+    disabledElt?: JhxTargetAttribute;
+    disinherit?: JhxInheritAttribute;
+    encoding?: string;
+    ext?: JhxExtensionAttribute;
+    get?: string;
+    headers?: JhxEvaluableAttribute<TDom>;
+    history?: boolean;
+    historyElt?: boolean;
+    include?: JhxTargetAttribute;
+    indicator?: JhxIndicatorAttribute;
+    inherit?: JhxInheritAttribute;
+    patch?: string;
+    params?: JhxParamsAttribute;
+    post?: string;
+    preserve?: boolean;
+    prompt?: string;
+    pushUrl?: boolean | string;
+    put?: string;
+    replaceUrl?: boolean | string;
+    request?: JhxRequestAttribute<TDom>;
+    select?: string;
+    selectOob?: JhxSelectOobAttribute;
+    swap?: JhxSwapAttribute;
+    swapOob?: JhxSwapOobAttribute;
+    sync?: JhxSyncAttribute;
+    target?: JhxTargetAttribute;
+    trigger?: JhxTriggerAttribute;
+    validate?: boolean;
+    vals?: JhxEvaluableAttribute<TDom>;
+    /** Deprecated. Use `vals` instead. */
+    vars?: never;
+}
+
+type JhxRouteProps = {
+    route?: string;
+    method?: HtmxHttpMethod;
+};
+
+/**
+ * Properties for configuring HTMX behavior, events, and methods.
+ * @template TDom Type for additional parameters received from the DOM.
+ */
+type JhxProps<TDom extends object = object> = HtmxProps<TDom> & HtmxEventProps<TDom> & JhxRouteProps & {};
+/**
+ * Properties for configuring HTMX behavior, events, methods, and standard DOM events.
+ * @template TDom Type for additional parameters received from the DOM.
+ */
+type JhxDomProps<TDom extends object = object> = HtmxProps<TDom> & HtmxEventProps<TDom> & JhxRouteProps & DomEventProps<TDom> & {};
+
+type NativeProps<TTag extends ElementType> = Omit<ComponentPropsWithoutRef<TTag>, 'children' | keyof JhxProps<any>>;
+type JhxComponentProps<TDom extends object = object, TTag extends ElementType = 'div'> = JhxProps<TDom> & NativeProps<TTag> & {
+    jhxConfig?: Omit<JhxConfig, 'stringify'>;
+    as?: TTag;
+};
+declare const JhxComponent: <TDom extends object = object, TTag extends ElementType = "div">(props: PropsWithChildren<JhxComponentProps<TDom, TTag>>) => JSX.Element;
+type JhxComponentType<TDom extends object = object, TTag extends keyof JSX.IntrinsicElements = 'div'> = typeof JhxComponent<TDom, TTag>;
+
+/**
+ * Applies a key-value pairs of HTML attributes to a given element.
+ *
+ * @param element The target HTML element to apply the attributes to.
+ * @param attributes An object containing key-value pairs of HTML attributes.
+ *
+ * @example
+ * ```ts
+ * import { applyAttributes } from 'jhx';
+ *
+ * const button = document.createElement('button');
+ * applyAttributes(button, {
+ *   'hx-get': '/api',
+ *   'hx-swap': 'outerHTML',
+ *   'custom-attribute': { id: 123, name: 'test' },
+ * });
+ * ```
+ */
+declare const applyAttributes: (element: Element, attributes: Record<string, unknown>) => void;
+
+/**
+ * Converts a record of HTML attributes into an HTML element attribute string.
+ *
+ * Typically used to format the attributes before sending to the client.
+ *
+ * @param attributes An object containing key-value pairs of HTML attributes.
+ * @param escape Whether to escape the HTML characters within string values. Defaults to `true`.
+ *
+ * @example
+ * ```ts
+ * import { attributesToString } from 'jhx';
+ *
+ * const attrs = attributesToString({
+ *   'hx-get': '/api',
+ *   'hx-swap': 'outerHTML',
+ * });
+ * // 'hx-get="/api" hx-swap="outerHTML"'
+ *
+ * const html = `<button ${attrs}>Click Me</button>`;
+ * ```
+ */
+declare const attributesToString: (attributes: Record<string, unknown>, escape?: boolean) => string;
+
+type JhxDefaultConfig = Required<JhxConfig>;
+/**
+ * Default jhx configuration
+ */
+declare const defaultConfig: JhxDefaultConfig;
+
+/**
+ * Escapes HTML special characters in all string values within the provided object.
+ *
+ * @param attributes An object containing key-value pairs of HTML attributes.
+ */
+declare const escapeAttributes: <T = Record<string, any>>(attributes: Record<string, any>) => T;
+
+/**
+ * Returns an object or string containing HTMX and HTML attributes.
+ * @template TDom Type for additional parameters from within the DOM. Defaults to `object`.
+ */
+declare function jhx<TDom extends object = object>(props: JhxDomProps<TDom>, config: Omit<JhxConfig, 'stringify'> & {
+    stringify: true;
+}): string;
+declare function jhx<TDom extends object = object>(props: JhxProps<TDom>, config: Omit<JhxConfig, 'stringify'> & {
+    stringify: false;
+}): Record<JhxAttribute, string>;
+declare function jhx<TDom extends object = object>(props: JhxProps<TDom>, config?: Omit<JhxConfig, 'stringify'> & {
+    stringify?: false;
+}): Record<JhxAttribute, string>;
+
+type JhxErrorAttribute = 'hx-headers' | 'hx-request' | 'hx-vals';
+interface JhxError extends Error {
+    attribute: JhxErrorAttribute;
+    message: JhxHeadersError['message'] | JhxRequestError['message'] | JhxValsError['message'] | (string & {});
+}
+interface JhxHeadersError extends JhxError {
+    attribute: 'hx-headers';
+    message: "[jhx] Error while parsing 'hx-headers' object";
+}
+interface JhxRequestError extends JhxError {
+    attribute: 'hx-request';
+    message: "[jhx] Error while parsing 'hx-request' object";
+}
+interface JhxValsError extends JhxError {
+    attribute: 'hx-vals';
+    message: "[jhx] Error while parsing 'hx-vals' object";
+}
+declare class JhxErrorThrowable extends Error implements JhxError {
+    attribute: JhxErrorAttribute;
+    constructor(message: JhxError['message'], options: {
+        attribute: JhxErrorAttribute;
+        cause?: unknown;
+        stack?: string;
+    });
+}
+
+export { JhxComponent, JhxErrorThrowable, applyAttributes, attributesToString, defaultConfig, escapeAttributes, htmx, jhx };
+export type { ConditionalFunction, CustomDomEventProps, DomEventProps, DomObjects, Duration, HtmxAbortEvent, HtmxAfterOnLoadEvent, HtmxAfterProcessNodeEvent, HtmxAfterRequestEvent, HtmxAfterSettleEvent, HtmxAfterSwapEvent, HtmxAjaxEtc, HtmxAjaxHandler, HtmxAttribute, HtmxBeforeCleanupElementEvent, HtmxBeforeHistorySaveEvent, HtmxBeforeOnLoadEvent, HtmxBeforeProcessNodeEvent, HtmxBeforeRequestEvent, HtmxBeforeSendEvent, HtmxBeforeSwapEvent, HtmxBeforeTransitionEvent, HtmxCacheItem, HtmxClass, HtmxConfig, HtmxConfigRequestEvent, HtmxConfirmEvent, HtmxDefaultExtension, HtmxDomEvent, HtmxElementValidationError, HtmxEvent, HtmxEventAttribute, HtmxEventDetail, HtmxEventName, HtmxEventProps, HtmxExtension, HtmxExtensionMetadata, HtmxHistoryCacheErrorEvent, HtmxHistoryCacheHitEvent, HtmxHistoryCacheMissEvent, HtmxHistoryCacheMissLoadErrorEvent, HtmxHistoryCacheMissLoadEvent, HtmxHistoryRestoreEvent, HtmxHttpMethod, HtmxHttpVerb, HtmxInstance, HtmxIssueRequest, HtmxLoadEvent, HtmxMethodAttribute, HtmxNoSseSourceErrorEvent, HtmxOnLoadErrorEvent, HtmxOobAfterSwapEvent, HtmxOobBeforeSwapEvent, HtmxOobErrorNoTargetEvent, HtmxPathInfo, HtmxPromptEvent, HtmxProps, HtmxPushedIntoHistoryEvent, HtmxReplacedInHistoryEvent, HtmxRequestConfig, HtmxRequestHeader, HtmxResponseErrorEvent, HtmxResponseHandlingConfig, HtmxResponseHeader, HtmxSendAbortEvent, HtmxSendErrorEvent, HtmxSettleInfo, HtmxSseErrorEvent, HtmxSseOpenEvent, HtmxSwapErrorEvent, HtmxSwapSpec, HtmxSwapStyle, HtmxSyncStrategy, HtmxTargetErrorEvent, HtmxTimeoutEvent, HtmxValidateUrlEvent, HtmxValidationFailedEvent, HtmxValidationHaltedEvent, HtmxValidationValidateEvent, HtmxXhrAbortEvent, HtmxXhrLoadendEvent, HtmxXhrLoadstartEvent, HtmxXhrProgressEvent, JhxAttribute, JhxComponentProps, JhxComponentType, JhxConfig, JhxDefaultConfig, JhxDomProps, JhxError, JhxErrorAttribute, JhxEvaluableAttribute, JhxExtensionAttribute, JhxHeadersError, JhxIndicatorAttribute, JhxInheritAttribute, JhxParamsAttribute, JhxProps, JhxRequestArgs, JhxRequestAttribute, JhxRequestError, JhxRouteProps, JhxSelectOobAttribute, JhxSwapAttribute, JhxSwapOobAttribute, JhxSwapScroll, JhxSwapShow, JhxSyncAttribute, JhxTargetAttribute, JhxTriggerAttribute, JhxTriggerAttribute_Intersect, JhxTriggerAttribute_Poll, JhxTriggerAttribute_Standard, JhxTriggerFrom, JhxTriggerQueue, JhxValsError, Logger };