@zeyos/zx 2.1.0 → 2.2.1

package/dist/types/core/component.d.ts

@@ -0,0 +1,115 @@
+export type ComponentOptions = Record<string, any>;
+export type ComponentListener = (event: Event & {
+    detail?: Record<string, unknown>;
+}) => void;
+/**
+ * Base class for lifecycle-safe Zx components.
+ *
+ * Generic over its own options type so a subclass can bind its `XOptions` typedef with
+ * `@extends {Component<XOptions>}`. That is what types `new Select(target, { … })` for editors and
+ * for TypeScript consumers: a subclass declares no constructor of its own, so it inherits this
+ * signature, and without the binding every component would accept any object at all.
+ *
+ * @template {ComponentOptions} [TOptions=ComponentOptions]
+ * @fires Component#event
+ */
+export declare class Component<TOptions extends ComponentOptions = ComponentOptions> extends EventTarget {
+    #private;
+    /** @type {ComponentOptions} */
+    static defaults: ComponentOptions;
+    /**
+     * BEM block a subclass wants on its root, without the `zx-` prefix. Empty on the base, which is
+     * the same falsy answer the undeclared property gave — declared so the statics are visible to
+     * `this.constructor` and to the generated declarations.
+     * @type {string}
+     */
+    static cssName: string;
+    /** @type {Element} Root element. */
+    el: Element;
+    /** @type {Record<string, Element>} Elements captured by `h()` ref properties. */
+    refs: Record<string, Element>;
+    /** @type {Readonly<TOptions>} Merged component options. */
+    options: Readonly<TOptions>;
+    /**
+     * Creates a component around an existing target, or asks `render()` to create its root.
+     * @param {Element|string|null} target Existing element, selector, or null.
+     * @param {TOptions} [options={}] Component options.
+     */
+    constructor(target: Element | string | null, options?: TOptions);
+    /**
+     * Renders or enhances the component root. Subclasses creating a root must return it.
+     * @returns {Element|null}
+     */
+    render(): Element | null;
+    /**
+     * Subscribes to a component-level event for this component's lifetime.
+     * @param {string} type Lowercase event name.
+     * @param {ComponentListener|EventListenerObject} fn Listener.
+     * @returns {this}
+     */
+    on(type: string, fn: ComponentListener | EventListenerObject): this;
+    /**
+     * Removes a component-level event listener.
+     * @param {string} type Event name.
+     * @param {ComponentListener|EventListenerObject} fn Listener.
+     * @returns {this}
+     */
+    off(type: string, fn: ComponentListener | EventListenerObject): this;
+    /**
+     * Subscribes to one component-level event occurrence.
+     * @param {string} type Event name.
+     * @param {ComponentListener|EventListenerObject} fn Listener.
+     * @returns {this}
+     */
+    once(type: string, fn: ComponentListener | EventListenerObject): this;
+    /**
+     * MooTools-compatible alias of `on()`.
+     * @param {string} type Event name.
+     * @param {ComponentListener|EventListenerObject} fn Listener.
+     * @returns {this}
+     */
+    addEvent(type: string, fn: ComponentListener | EventListenerObject): this;
+    /**
+     * Dispatches a component event and a bubbling, composed `zx-*` DOM event.
+     * @param {string} type Lowercase event name.
+     * @param {Record<string, unknown>} [detail={}] Single event detail object.
+     * @returns {Event & {detail: Record<string, unknown>}}
+     * @fires Component#event
+     */
+    emit(type: string, detail?: Record<string, unknown>): Event & {
+        detail: Record<string, unknown>;
+    };
+    /**
+     * Adds an automatically cleaned-up DOM event listener.
+     * @param {EventTarget} element DOM event target.
+     * @param {string} type Event name.
+     * @param {EventListenerOrEventListenerObject} fn Listener.
+     * @param {boolean|AddEventListenerOptions} [opts={}] Listener options.
+     * @returns {this}
+     */
+    listen(element: EventTarget, type: string, fn: EventListenerOrEventListenerObject, opts?: boolean | AddEventListenerOptions): this;
+    /**
+     * Returns the component's root element.
+     * @returns {Element}
+     */
+    toElement(): Element;
+    /**
+     * Resolves and interpolates a component-local or global translation.
+     * @param {string} key Message key.
+     * @param {...unknown} args Positional interpolation values.
+     * @returns {string}
+     */
+    msg(key: string, ...args: unknown[]): string;
+    /**
+     * Aborts listeners, unregisters the component, and removes roots created by the component.
+     * Safe to call repeatedly.
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Retrieves the component currently registered for an element.
+     * @param {Element} element Root element.
+     * @returns {Component|null}
+     */
+    static from(element: Element): Component | null;
+}

package/dist/types/core/date.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Formats a local Date using strftime-style kernel tokens.
+ * @param {Date} date Date to format.
+ * @param {string} fmt Format containing `%d %e %m %Y %y %H %M %S %a %A %b %B %s` tokens.
+ * @returns {string}
+ */
+export declare function formatDate(date: Date, fmt: string): string;
+/**
+ * Parses numeric date tokens from a string, returning null for mismatches or invalid dates.
+ * Unspecified fields default to 1970-01-01 00:00:00 local time.
+ * @param {string} str Date text.
+ * @param {string} fmt Matching numeric format.
+ * @returns {Date|null}
+ */
+export declare function parseDate(str: string, fmt: string): Date | null;
+/**
+ * Clamps a date to optional inclusive bounds and returns a new Date.
+ * @param {Date} date Date to clamp.
+ * @param {Date|null|undefined} min Minimum date.
+ * @param {Date|null|undefined} max Maximum date.
+ * @returns {Date}
+ */
+export declare function clampDate(date: Date, min: Date | null | undefined, max: Date | null | undefined): Date;
+/**
+ * Reports whether two dates share the same local calendar day.
+ * @param {Date} a First date.
+ * @param {Date} b Second date.
+ * @returns {boolean}
+ */
+export declare function isSameDay(a: Date, b: Date): boolean;
+/**
+ * Adds local calendar days without mutating the input.
+ * @param {Date} date Base date.
+ * @param {number} n Number of days.
+ * @returns {Date}
+ */
+export declare function addDays(date: Date, n: number): Date;
+/**
+ * Adds local calendar months without mutating the input, clamping to the target month's end.
+ * @param {Date} date Base date.
+ * @param {number} n Number of months.
+ * @returns {Date}
+ */
+export declare function addMonths(date: Date, n: number): Date;
+/**
+ * Returns the locale's first weekday (`0` Sunday through `6` Saturday), Monday by default.
+ * @param {string} [lang=getLanguage()] BCP 47 language tag.
+ * @returns {number}
+ */
+export declare function getWeekStart(lang?: string): number;

package/dist/types/core/dom.d.ts

@@ -0,0 +1,86 @@
+export type ElementProvider = {
+    toElement: () => Node | null;
+};
+export type DomChild = Node | string | number | ElementProvider | null | undefined | Array<DomChild>;
+export type HProps = {
+    /**
+     * Class name or names.
+     */
+    class?: string | string[];
+    /**
+     * Inline styles.
+     */
+    style?: string | Record<string, string | number>;
+    /**
+     * Data properties.
+     */
+    dataset?: Record<string, unknown>;
+    /**
+     * Ref name collected by `h.scope()`.
+     */
+    ref?: string;
+};
+/**
+ * Creates an element and appends normalized children.
+ * @param {string} tag Element tag name.
+ * @param {(HProps & Record<string, any>)|DomChild} [props] Properties and attributes, or the first child.
+ * @param {...DomChild} children Child values.
+ * @returns {HTMLElement}
+ */
+export declare function h(tag: string, props?: (HProps & Record<string, any>) | DomChild, ...children: DomChild[]): HTMLElement;
+export declare namespace h {
+    var scope: <T>(refs: Record<string, Element>, fn: () => T) => T;
+    var raw: (html: string) => DocumentFragment;
+}
+export type TargetSnapshot = {
+    children: Node[];
+    attributes: [string, string][];
+};
+/** @typedef {{children: Node[], attributes: [string, string][]}} TargetSnapshot */
+/**
+ * Captures an enhanced target's children and attributes so `destroy()` can put it back exactly as
+ * it was found.
+ * @param {Element} element Target being taken over.
+ * @returns {TargetSnapshot}
+ */
+export declare function snapshotTarget(element: Element): TargetSnapshot;
+/**
+ * Restores a target captured by `snapshotTarget()`.
+ * @param {Element} element Target to restore.
+ * @param {TargetSnapshot|null} snapshot Snapshot taken before the takeover, or null to do nothing.
+ * @returns {void}
+ */
+export declare function restoreTarget(element: Element, snapshot: TargetSnapshot | null): void;
+/**
+ * Escapes text for safe insertion into an HTML string.
+ * @param {unknown} str Value to escape.
+ * @returns {string}
+ */
+export declare function htmlEscape(str: unknown): string;
+export type HighlightOptions = {
+    /**
+     * Class applied to each generated `<mark>`.
+     */
+    className?: string;
+};
+/**
+ * @typedef {Object} HighlightOptions
+ * @property {string} [className='zx-mark'] Class applied to each generated `<mark>`.
+ */
+/**
+ * Wraps every case-insensitive occurrence of a query in a `<mark>` element and returns the result
+ * as a fragment. The text is placed in text nodes and the marks are built element by element, so
+ * this is safe for user and server data — no HTML is ever parsed. An empty or whitespace-only
+ * query yields the text unchanged in a single text node.
+ * @param {unknown} text Text to search.
+ * @param {unknown} query Search term, matched literally.
+ * @param {HighlightOptions} [options={}] Marking options.
+ * @returns {DocumentFragment}
+ */
+export declare function highlightMatch(text: unknown, query: unknown, options?: HighlightOptions): DocumentFragment;
+/**
+ * Resolves an Element, selector, or object exposing `toElement()`.
+ * @param {Element|string|ElementProvider|null|undefined} target Target to resolve.
+ * @returns {Element|null}
+ */
+export declare function resolveElement(target: Element | string | ElementProvider | null | undefined): Element | null;

package/dist/types/core/export.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @typedef {Object} CsvColumn
+ * @property {string} id Row property read when no `value` accessor is given, and the default label.
+ * @property {string} [label] Header text; defaults to `id`.
+ * @property {(row: any) => unknown} [value] Accessor returning the cell value for a row.
+ */
+export type CsvColumn = {
+    /**
+     * Row property read when no `value` accessor is given, and the default label.
+     */
+    id: string;
+    /**
+     * Header text; defaults to `id`.
+     */
+    label?: string;
+    /**
+     * Accessor returning the cell value for a row.
+     */
+    value?: (row: any) => unknown;
+};
+export type CsvOptions = {
+    /**
+     * Field separator; use `';'` for German Excel locales.
+     */
+    delimiter?: string;
+    /**
+     * Whether to emit the header row.
+     */
+    header?: boolean;
+    /**
+     * Record separator; RFC 4180 uses CRLF.
+     */
+    newline?: string;
+};
+export type DownloadOptions = {
+    /**
+     * MIME type of the generated blob.
+     */
+    type?: string;
+};
+/**
+ * Serialises rows to RFC 4180 CSV text.
+ *
+ * Fields containing the delimiter, a double quote, CR, or LF are quoted with inner quotes doubled.
+ * Dates become ISO strings, null and undefined become empty fields, and text that starts with
+ * `=`, `+`, `-`, or `@` is prefixed with a tab so spreadsheets treat it as text rather than a
+ * formula. Numbers are never prefixed, so negative amounts survive intact.
+ *
+ * @param {Iterable<any>|null|undefined} rows Row objects.
+ * @param {Array<string|CsvColumn>} columns Column ids, or descriptors with a label and accessor.
+ * @param {CsvOptions} [options={}] Serialisation options.
+ * @returns {string}
+ */
+export declare function toCsv(rows: Iterable<any> | null | undefined, columns: Array<string | CsvColumn>, options?: CsvOptions): string;
+/**
+ * Saves data to the user's downloads through a temporary object URL and anchor click.
+ * A UTF-8 BOM is prepended to CSV strings so Excel reads them as UTF-8.
+ * @param {string} filename Suggested file name including its extension.
+ * @param {string|Blob|ArrayBuffer|ArrayBufferView} data Payload to save.
+ * @param {DownloadOptions} [options={}] Blob options.
+ * @returns {void}
+ */
+export declare function downloadBlob(filename: string, data: string | Blob | ArrayBuffer | ArrayBufferView, options?: DownloadOptions): void;
+/**
+ * Copies text to the clipboard, falling back to a hidden textarea when the async Clipboard API is
+ * unavailable or blocked. Never rejects.
+ * @param {string} text Text to copy.
+ * @returns {Promise<boolean>} Whether the copy succeeded.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;

package/dist/types/core/fontawesome.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Font Awesome knowledge for the icon layer: style/family class names, the built-in glyph
+ * name → Font Awesome name map, icon-spec parsing, and kit loading.
+ *
+ * Nothing here is imported by a component. `icons.js` uses it only after an application opts in
+ * with `useFontAwesome()` / `loadFontAwesome()`, so the zero-dependency default is untouched: Zx
+ * never fetches a kit, a stylesheet, or a webfont on its own.
+ */
+/**
+ * Font Awesome style names mapped to their CSS class. `kit` is the pseudo-style for custom icons
+ * uploaded to a kit (`fa-kit fa-zeyos-notes`).
+ * @type {Readonly<Record<string, string>>}
+ */
+export declare const faStyles: Readonly<Record<string, string>>;
+/**
+ * Font Awesome families mapped to their CSS class. `classic` is the default and adds no class.
+ * @type {Readonly<Record<string, string>>}
+ */
+export declare const faFamilies: Readonly<Record<string, string>>;
+/**
+ * Built-in Zx glyph names mapped to their Font Awesome 6/7 counterpart, so the same component
+ * code renders either provider. Names not listed here are passed to Font Awesome unchanged.
+ * @type {Readonly<Record<string, string>>}
+ */
+export declare const faNames: Readonly<Record<string, string>>;
+export type IconSpec = {
+    /**
+     * Renderer the spec named, null when it named none.
+     */
+    provider: 'fa' | 'builtin' | null;
+    /**
+     * Bare icon name (`'user'`, `'zeyos-notes'`), empty for literal specs.
+     */
+    name: string;
+    /**
+     * Style named by the spec, if any.
+     */
+    style: string | null;
+    /**
+     * Literal class list when the spec was already CSS classes.
+     */
+    classes: string[] | null;
+};
+/**
+ * @typedef {Object} IconSpec
+ * @property {'fa'|'builtin'|null} provider Renderer the spec named, null when it named none.
+ * @property {string} name Bare icon name (`'user'`, `'zeyos-notes'`), empty for literal specs.
+ * @property {string|null} style Style named by the spec, if any.
+ * @property {string[]|null} classes Literal class list when the spec was already CSS classes.
+ */
+/**
+ * Parses an icon spec into the renderer it names and the icon name it carries. Recognised forms:
+ *
+ * - `'fa-solid fa-user'`, `'fa-kit fa-zeyos-notes'` — a literal class list, used as given.
+ * - `'fa:user'`, `'fas:user'`, `'duotone:user'`, `'kit:zeyos-notes'` — prefix plus icon name.
+ * - `'builtin:check'` — forces one of the bundled inline SVG glyphs.
+ * - `'user'` — a bare name, left for the caller's active provider to interpret.
+ *
+ * @param {string} spec Icon spec.
+ * @returns {IconSpec}
+ */
+export declare function parseIconSpec(spec: string): IconSpec;
+export type FaClassOptions = {
+    /**
+     * Style name from `faStyles`.
+     */
+    style?: string;
+    /**
+     * Family name from `faFamilies`.
+     */
+    family?: string;
+    /**
+     * Adds `fa-fw` for column-aligned glyphs.
+     */
+    fixedWidth?: boolean;
+    /**
+     * Maps built-in Zx glyph names through `faNames`.
+     */
+    translate?: boolean;
+};
+/**
+ * @typedef {Object} FaClassOptions
+ * @property {string} [style='solid'] Style name from `faStyles`.
+ * @property {string} [family='classic'] Family name from `faFamilies`.
+ * @property {boolean} [fixedWidth=false] Adds `fa-fw` for column-aligned glyphs.
+ * @property {boolean} [translate=true] Maps built-in Zx glyph names through `faNames`.
+ */
+/**
+ * Builds the Font Awesome class list for an icon name.
+ * @param {string} name Font Awesome icon name, with or without the `fa-` prefix.
+ * @param {FaClassOptions} [options={}] Style, family, and modifiers.
+ * @returns {string[]} Class names, style/family first.
+ */
+export declare function faIconClasses(name: string, options?: FaClassOptions): string[];
+/**
+ * Expands a kit token into its script URL. Full URLs and paths are returned unchanged.
+ * @param {string} kit Kit token (`'ae8320b210'`) or script URL.
+ * @returns {string}
+ */
+export declare function kitUrl(kit: string): string;
+/**
+ * Loads a Font Awesome kit script once per URL. Repeat calls return the first promise, and a kit
+ * the host page already embedded is adopted rather than loaded twice.
+ * @param {string} kit Kit token or script URL.
+ * @returns {Promise<void>} Resolves when the kit has loaded.
+ */
+export declare function loadFontAwesomeKit(kit: string): Promise<void>;

package/dist/types/core/format.d.ts

@@ -0,0 +1,107 @@
+export type NumberFormatOptions = {
+    /**
+     * BCP 47 language tag; defaults to the active language.
+     */
+    locale?: string;
+    /**
+     * Shorthand setting both the minimum and maximum fraction digits.
+     */
+    decimals?: number;
+    /**
+     * Minimum fraction digits.
+     */
+    minDecimals?: number;
+    /**
+     * Maximum fraction digits.
+     */
+    maxDecimals?: number;
+    /**
+     * Whether to insert the locale's grouping separators.
+     */
+    group?: boolean;
+};
+export type CurrencyFormatOptions = {
+    /**
+     * BCP 47 language tag.
+     */
+    locale?: string;
+    /**
+     * Fraction digits; defaults to the currency's own minor-unit count.
+     */
+    decimals?: number;
+};
+export type PercentFormatOptions = {
+    /**
+     * BCP 47 language tag.
+     */
+    locale?: string;
+    /**
+     * Fraction digits.
+     */
+    decimals?: number;
+};
+export type FileSizeFormatOptions = {
+    /**
+     * BCP 47 language tag.
+     */
+    locale?: string;
+    /**
+     * Maximum fraction digits; trailing zeros are dropped.
+     */
+    decimals?: number;
+    /**
+     * Binary KiB/MiB/GiB or decimal kB/MB/GB units.
+     */
+    standard?: 'iec' | 'si';
+};
+export type RelativeTimeFormatOptions = {
+    /**
+     * Reference point the date is measured against.
+     */
+    now?: Date | number | string;
+    /**
+     * BCP 47 language tag.
+     */
+    locale?: string;
+    /**
+     * `auto` produces "yesterday", `always` "1 day ago".
+     */
+    numeric?: 'auto' | 'always';
+};
+/**
+ * Formats a number for the active language.
+ * @param {number|string|null|undefined} value Value to format.
+ * @param {NumberFormatOptions} [options={}] Formatting options.
+ * @returns {string} Formatted number, or an empty string for null, undefined, and NaN.
+ */
+export declare function formatNumber(value: number | string | null | undefined, options?: NumberFormatOptions): string;
+/**
+ * Formats a monetary amount, falling back to plain number formatting when the currency code is
+ * missing or not shaped like an ISO 4217 code.
+ * @param {number|string|null|undefined} value Amount to format.
+ * @param {string|null|undefined} currency Three-letter ISO 4217 code such as `EUR`.
+ * @param {CurrencyFormatOptions} [options={}] Formatting options.
+ * @returns {string} Formatted amount, or an empty string for null, undefined, and NaN.
+ */
+export declare function formatCurrency(value: number | string | null | undefined, currency: string | null | undefined, options?: CurrencyFormatOptions): string;
+/**
+ * Formats a fraction as a percentage: `0.42` becomes `42%`.
+ * @param {number|string|null|undefined} value Fraction to format.
+ * @param {PercentFormatOptions} [options={}] Formatting options.
+ * @returns {string} Formatted percentage, or an empty string for null, undefined, and NaN.
+ */
+export declare function formatPercent(value: number | string | null | undefined, options?: PercentFormatOptions): string;
+/**
+ * Formats a byte count with binary (KiB) or decimal (kB) units.
+ * @param {number|string|null|undefined} bytes Byte count.
+ * @param {FileSizeFormatOptions} [options={}] Formatting options.
+ * @returns {string} Formatted size, `'0 B'` for zero, or an empty string for null and NaN.
+ */
+export declare function formatFileSize(bytes: number | string | null | undefined, options?: FileSizeFormatOptions): string;
+/**
+ * Formats a date relative to a reference point, picking the largest sensible unit.
+ * @param {Date|number|string|null|undefined} date Date, Unix timestamp in seconds, or ISO string.
+ * @param {RelativeTimeFormatOptions} [options={}] Formatting options.
+ * @returns {string} Formatted phrase, or an empty string when the date cannot be read.
+ */
+export declare function formatRelativeTime(date: Date | number | string | null | undefined, options?: RelativeTimeFormatOptions): string;

package/dist/types/core/http.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @typedef {Object} HttpOptions
+ * @property {string} [base=''] URL prefix.
+ * @property {Record<string, string>} [headers={}] Default request headers.
+ * @property {((error: Error, context: {path: string, options: RequestOptions}) => void)|null} [onError=null]
+ * @property {number} [timeout=30000] Timeout in milliseconds; zero disables it.
+ */
+export type HttpOptions = {
+    /**
+     * URL prefix.
+     */
+    base?: string;
+    /**
+     * Default request headers.
+     */
+    headers?: Record<string, string>;
+    onError?: ((error: Error, context: {
+        path: string;
+        options: RequestOptions;
+    }) => void) | null;
+    /**
+     * Timeout in milliseconds; zero disables it.
+     */
+    timeout?: number;
+};
+export type RequestOptions = {
+    /**
+     * HTTP method.
+     */
+    method?: string;
+    /**
+     * JSON or form data.
+     */
+    data?: unknown;
+    /**
+     * Files that switch the body to FormData.
+     */
+    files?: File | FileList | File[];
+    /**
+     * Query parameters.
+     */
+    query?: string | URLSearchParams | Record<string, unknown>;
+    /**
+     * Per-request headers.
+     */
+    headers?: Record<string, string>;
+};
+/**
+ * @typedef {Object} RequestOptions
+ * @property {string} [method='GET'] HTTP method.
+ * @property {unknown} [data=null] JSON or form data.
+ * @property {File|FileList|File[]} [files=null] Files that switch the body to FormData.
+ * @property {string|URLSearchParams|Record<string, unknown>} [query=null] Query parameters.
+ * @property {Record<string, string>} [headers={}] Per-request headers.
+ */
+/** Dependency-free JSON fetch wrapper with legacy ZeyOS envelope handling. */
+export declare class Http {
+    /** @type {string} */
+    base: string;
+    /** @type {Readonly<Record<string, string>>} */
+    headers: Readonly<Record<string, string>>;
+    /** @type {HttpOptions['onError']} */
+    onError: HttpOptions['onError'];
+    /** @type {number} */
+    timeout: number;
+    /**
+     * @param {HttpOptions} [options={}] Client defaults.
+     */
+    constructor({ base, headers, onError, timeout }?: HttpOptions);
+    /**
+     * Performs a request and returns its parsed JSON payload or legacy `result` value.
+     * @param {string} path Path relative to the configured base.
+     * @param {RequestOptions} [options={}] Request settings.
+     * @returns {Promise<any>}
+     */
+    request(path: string, options?: RequestOptions): Promise<any>;
+    /**
+     * Sends a GET request with query parameters.
+     * @param {string} path Request path.
+     * @param {RequestOptions['query']} [query=null] Query parameters.
+     * @returns {Promise<any>}
+     */
+    get(path: string, query?: RequestOptions['query']): Promise<any>;
+    /**
+     * Sends a POST request with a JSON body.
+     * @param {string} path Request path.
+     * @param {unknown} [data=null] Request data.
+     * @returns {Promise<any>}
+     */
+    post(path: string, data?: unknown): Promise<any>;
+    /**
+     * Sends a PUT request with a JSON body.
+     * @param {string} path Request path.
+     * @param {unknown} [data=null] Request data.
+     * @returns {Promise<any>}
+     */
+    put(path: string, data?: unknown): Promise<any>;
+    /**
+     * Sends a DELETE request with a JSON body.
+     * @param {string} path Request path.
+     * @param {unknown} [data=null] Request data.
+     * @returns {Promise<any>}
+     */
+    delete(path: string, data?: unknown): Promise<any>;
+}
+/**
+ * Creates an Http client for a ZeyOS remote-call service.
+ * @param {string} service Service name.
+ * @param {string} [accesskey=''] Optional service access key.
+ * @param {HttpOptions & {apiBase?: string}} [options={}] Client and API-base options.
+ * @returns {Http}
+ */
+export declare function zeyosService(service: string, accesskey?: string, options?: HttpOptions & {
+    apiBase?: string;
+}): Http;
+/**
+ * Unwraps a legacy `{result}` response or throws a legacy `{error}` response.
+ * JSON values without either envelope key pass through unchanged.
+ * @param {any} json Parsed JSON value.
+ * @returns {any}
+ */
+export declare function parseResult(json: any): any;