import { DatastarEventOptions, EventType, PatchElementsOptions, PatchSignalsOptions } from "./types.js";
/**
 * Abstract ServerSentEventGenerator class, responsible for initializing and handling
 * server-sent events (SSE) as well as reading signals sent by the client.
 *
 * The concrete implementation must override the send and constructor methods as well
 * as implement readSignals and stream static methods.
 */
export declare abstract class ServerSentEventGenerator<T = string[]> {
    protected constructor();
    /**
     * Validates that the provided mode is a valid ElementPatchMode.
     * @param mode - The mode to validate
     * @throws {Error} If the mode is invalid
     */
    private validateElementPatchMode;
    /**
     * Validates that the provided namespace is a valid NamespaceType.
     * @param namespace - The namespace to validate
     * @throws {Error} If the namespace is invalid
     */
    private validateNamespace;
    /**
     * Validates required parameters are not empty or undefined.
     * @param value - The value to validate
     * @param paramName - The parameter name for error messages
     * @throws {Error} If the value is empty or undefined
     */
    private validateRequired;
    /**
     * Sends a server-sent event (SSE) to the client.
     *
     * Runtimes should override this method by calling the parent function
     *  with `super.send(event, dataLines, options)`. That will return all the
     * datalines as an array of strings that should be streamed to the client.
     *
     * @param eventType - The type of the event.
     * @param dataLines - Lines of data to send.
     * @param [sendOptions] - Additional options for sending events.
     */
    protected send(event: EventType, dataLines: string[], options: DatastarEventOptions): T | string[];
    /**
     * Closes the server-sent event stream.
     *
     * Use this method to manually close the stream when `keepalive: true` is set.
     * This is required when you want to close the stream before the client disconnects.
     *
     * Concrete implementations must override this method to close the underlying stream.
     */
    abstract close(): void;
    private eachNewlineIsADataLine;
    private eachOptionIsADataLine;
    private hasDefaultValue;
    /**
     * Patches HTML elements into the DOM.
     *
     * Use this to insert, update, or remove elements in the client DOM. Supports various patch modes and options.
     *
     * Examples:
     * ```
     * // Insert new element inside #container
     * patchElements('<div id="new">Hello</div>', { selector: '#container', mode: 'append' });
     *
     * // Replace element by ID
     * patchElements('<div id="replaceMe">Replaced</div>');
     *
     * // Remove by selector, note that you can also use removeElements
     * patchElements('', { selector: '#toRemove', mode: 'remove' });
     *
     * // Remove by elements with IDs, note that you can also use removeElements
     * patchElements('<div id="first"></div><div id="second"></div>', { mode: 'remove' });
     * ```
     *
     * @param elements - HTML string of elements to patch (must have IDs unless using selector).
     * @param options - Patch options: selector, mode, namespace, useViewTransition, eventId, retryDuration.
     * @returns The SSE lines to send.
     */
    patchElements(elements: string, options?: PatchElementsOptions): ReturnType<typeof this.send>;
    /**
     * Patches signals into the signal store.
     *
     * Use this to update client-side signals using RFC 7386 JSON Merge Patch semantics.
     *
     * Examples:
     * ```
     * // Patch a single signal
     * patchSignals('{"show": true}');
     *
     * // Patch multiple signals with onlyIfMissing option
     * patchSignals('{"output": "Test", "user": {"name": "Alice"}}', { onlyIfMissing: true });
     * ```
     *
     * @param signals - JSON string containing signal data to patch.
     * @param options - Patch options: onlyIfMissing, eventId, retryDuration.
     * @returns The SSE lines to send.
     */
    patchSignals(signals: string, options?: PatchSignalsOptions): ReturnType<typeof this.send>;
    /**
     * Executes a script on the client by sending a <script> tag via SSE.
     *
     * Use this to run JavaScript in the client browser. By default, the script tag will auto-remove after execution.
     *
     * Examples:
     * ```
     * // Execute a simple script
     * executeScript('console.log("Hello from server!")');
     *
     * // Execute a script and keep it in the DOM
     * executeScript('alert("Persistent!")', { autoRemove: false });
     *
     * // Execute with custom attributes (object form preferred)
     * executeScript('doSomething()', { attributes: { type: "module", async: "true" } });
     *
     * // (Advanced) Execute with custom attributes as array of strings
     * executeScript('doSomething()', { attributes: ['type="module"', 'async'] });
     * ```
     *
     * @param script - The JavaScript code to execute.
     * @param options - Options: autoRemove, attributes (object preferred), eventId, retryDuration.
     * @returns The SSE lines to send.
     */
    executeScript(script: string, options?: {
        autoRemove?: boolean;
        attributes?: string[] | Record<string, string>;
        eventId?: string;
        retryDuration?: number;
    }): ReturnType<typeof this.send>;
    /**
     * Convenience method to remove elements from the DOM.
     *
     * Provide either a CSS selector (to remove all matching elements) OR an HTML string of elements with IDs (to remove specific elements by ID).
     *
     * - If `selector` is provided, it will be used to target elements for removal (elements param is ignored).
     * - If `selector` is not provided, `elements` must be a non-empty HTML string where each top-level element has an ID.
     *
     * Examples:
     * ```
     *   // Remove by selector
     *   removeElements('#feed, #otherid');
     *   // Remove by HTML elements with IDs
     *   removeElements(undefined, '<div id="first"></div><div id="second"></div>');
     * ```
     * @param selector - CSS selector for elements to remove (optional; mutually exclusive with elements).
     * @param elements - HTML string of elements with IDs to remove (optional; required if selector is not provided).
     * @param options - Additional options: eventId, retryDuration.
     * @returns The SSE lines to send.
     */
    removeElements(selector?: string, elements?: string, options?: {
        eventId?: string;
        retryDuration?: number;
    }): ReturnType<typeof this.send>;
    /**
     * Convenience method to remove one or more signals from the client signal store.
     *
     * This sends a JSON Merge Patch where each specified key is set to null, per RFC 7386 and the Datastar spec.
     *
     * Examples:
     * ```
     * // Remove a single signal
     * removeSignals('foo');
     *
     * // Remove multiple signals
     * removeSignals(['foo', 'bar']);
     *
     * // Remove with options
     * removeSignals('foo', { eventId: '123' });
     * ```
     *
     * @param signalKeys - The signal key or array of keys to remove.
     * @param options - Patch options: onlyIfMissing, eventId, retryDuration.
     * @returns The SSE lines to send.
     */
    removeSignals(signalKeys: string | string[], options?: {
        onlyIfMissing?: boolean;
        eventId?: string;
        retryDuration?: number;
    }): ReturnType<typeof this.send>;
}
//# sourceMappingURL=abstractServerSentEventGenerator.d.ts.map