eventsourcingdb 1.9.1 → 2.0.0

package/dist/http/trackSending.js

@@ -0,0 +1,46 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import diagnosticsChannel from 'node:diagnostics_channel';
+const currentSending = new AsyncLocalStorage();
+const sendingByRequest = new WeakMap();
+const getRequest = (message) => {
+    if (typeof message !== 'object' || message === null || !('request' in message)) {
+        return;
+    }
+    const { request } = message;
+    if (typeof request !== 'object' || request === null) {
+        return;
+    }
+    return request;
+};
+// The fetch built into Node.js creates its request within the call of fetch,
+// so the request belongs to the write that runs there.
+diagnosticsChannel.subscribe('undici:request:create', (message) => {
+    const sending = currentSending.getStore();
+    const request = getRequest(message);
+    if (sending === undefined || request === undefined || sending.state !== 'unknown') {
+        return;
+    }
+    sending.state = 'created';
+    sendingByRequest.set(request, sending);
+});
+diagnosticsChannel.subscribe('undici:client:sendHeaders', (message) => {
+    const request = getRequest(message);
+    const sending = request === undefined ? undefined : sendingByRequest.get(request);
+    if (sending !== undefined) {
+        sending.state = 'sent';
+    }
+});
+// Runs a write and tells, if it fails, whether its request certainly did not
+// reach the server, since it was created but its headers never went out. If
+// the client cannot tell, for example since fetch is not the one built into
+// Node.js, the request counts as sent.
+const trackSending = async (write) => {
+    const sending = { state: 'unknown' };
+    try {
+        return { result: await currentSending.run(sending, write) };
+    }
+    catch (error) {
+        return { error, hasBeenSent: sending.state !== 'created' };
+    }
+};
+export { trackSending };

package/dist/http/waitUnlessAborted.d.ts

@@ -0,0 +1,2 @@
+declare const waitUnlessAborted: <TResult>(promise: Promise<TResult>, signal?: AbortSignal) => Promise<TResult>;
+export { waitUnlessAborted };

package/dist/http/waitUnlessAborted.js

@@ -0,0 +1,21 @@
+// Waits for a promise that other callers may share, unless the signal of this
+// caller aborts first, which then rejects with its reason, while the promise
+// goes on for the others.
+const waitUnlessAborted = async (promise, signal) => {
+    if (signal === undefined) {
+        return await promise;
+    }
+    signal.throwIfAborted();
+    const aborted = Promise.withResolvers();
+    const onAbort = () => {
+        aborted.reject(signal.reason);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        return await Promise.race([promise, aborted.promise]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+};
+export { waitUnlessAborted };

package/dist/index.d.ts

@@ -1,15 +1,24 @@
 import { Client } from './Client.js';
+import type { ClientOptions } from './ClientOptions.js';
+import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
+import type { DbApiErrorOptions } from './DbApiError.js';
+import { DbApiError } from './DbApiError.js';
+import { ErrorCode } from './ErrorCode.js';
 import type { Event } from './Event.js';
 import type { EventCandidate } from './EventCandidate.js';
 import type { EventType } from './EventType.js';
-import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.js';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
 import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
 import { isSubjectOnEventId } from './isSubjectOnEventId.js';
 import { isSubjectPopulated } from './isSubjectPopulated.js';
 import { isSubjectPristine } from './isSubjectPristine.js';
 import type { ObserveEventsOptions } from './ObserveEventsOptions.js';
+import { OutcomeUnknownError } from './OutcomeUnknownError.js';
 import type { Precondition } from './Precondition.js';
 import type { ReadEventsOptions } from './ReadEventsOptions.js';
-export type { Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, };
-export { Client, Container, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };
+import type { ReadSubjectsOptions } from './ReadSubjectsOptions.js';
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+export type { ClientOptions, DbApiErrorOptions, Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, ReadSubjectsOptions, };
+export { Client, ConnectionStalledError, Container, DbApiError, ErrorCode, HashVerificationFailedError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, OutcomeUnknownError, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/index.js

@@ -1,8 +1,14 @@
 import { Client } from './Client.js';
+import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
-import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.js';
+import { DbApiError } from './DbApiError.js';
+import { ErrorCode } from './ErrorCode.js';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
 import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
 import { isSubjectOnEventId } from './isSubjectOnEventId.js';
 import { isSubjectPopulated } from './isSubjectPopulated.js';
 import { isSubjectPristine } from './isSubjectPristine.js';
-export { Client, Container, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };
+import { OutcomeUnknownError } from './OutcomeUnknownError.js';
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+export { Client, ConnectionStalledError, Container, DbApiError, ErrorCode, HashVerificationFailedError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, OutcomeUnknownError, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/json/getRawJsonElements.d.ts

@@ -0,0 +1,2 @@
+declare const getRawJsonElements: (text: string) => string[];
+export { getRawJsonElements };

package/dist/json/getRawJsonElements.js

@@ -0,0 +1,22 @@
+import { scanJsonValue, skipJsonWhitespace } from './scanJson.js';
+// Returns the elements of a JSON array exactly as the text contains them, or
+// an empty array if the text is not an array.
+const getRawJsonElements = (text) => {
+    const elements = [];
+    let position = skipJsonWhitespace(text, 0);
+    if (text[position] !== '[') {
+        return elements;
+    }
+    position = skipJsonWhitespace(text, position + 1);
+    while (position < text.length && text[position] !== ']') {
+        const elementEnd = scanJsonValue(text, position);
+        elements.push(text.slice(position, elementEnd));
+        position = skipJsonWhitespace(text, elementEnd);
+        if (text[position] !== ',') {
+            break;
+        }
+        position = skipJsonWhitespace(text, position + 1);
+    }
+    return elements;
+};
+export { getRawJsonElements };

package/dist/json/getRawJsonMember.d.ts

@@ -0,0 +1,2 @@
+declare const getRawJsonMember: (text: string, key: string) => string | undefined;
+export { getRawJsonMember };

package/dist/json/getRawJsonMember.js

@@ -0,0 +1,29 @@
+import { scanJsonString, scanJsonValue, skipJsonWhitespace } from './scanJson.js';
+// Returns the value of a member of a JSON object exactly as the text contains
+// it, or undefined if the text is not an object or has no such member. If the
+// object has the member more than once, the last one wins, as with JSON.parse.
+const getRawJsonMember = (text, key) => {
+    let position = skipJsonWhitespace(text, 0);
+    if (text[position] !== '{') {
+        return;
+    }
+    position = skipJsonWhitespace(text, position + 1);
+    let rawValue;
+    while (text[position] === '"') {
+        const keyEnd = scanJsonString(text, position);
+        const currentKey = JSON.parse(text.slice(position, keyEnd));
+        const colon = skipJsonWhitespace(text, keyEnd);
+        const valueStart = skipJsonWhitespace(text, colon + 1);
+        const valueEnd = scanJsonValue(text, valueStart);
+        if (currentKey === key) {
+            rawValue = text.slice(valueStart, valueEnd);
+        }
+        position = skipJsonWhitespace(text, valueEnd);
+        if (text[position] !== ',') {
+            break;
+        }
+        position = skipJsonWhitespace(text, position + 1);
+    }
+    return rawValue;
+};
+export { getRawJsonMember };

package/dist/json/scanJson.d.ts

@@ -0,0 +1,4 @@
+declare const skipJsonWhitespace: (text: string, start: number) => number;
+declare const scanJsonString: (text: string, start: number) => number;
+declare const scanJsonValue: (text: string, start: number) => number;
+export { scanJsonString, scanJsonValue, skipJsonWhitespace };

package/dist/json/scanJson.js

@@ -0,0 +1,65 @@
+// These functions find where a value starts and ends in a JSON text, so that
+// the SDK can take a value exactly as the server sent it, byte for byte. They
+// expect valid JSON, since the SDK only scans texts that JSON.parse accepted.
+const isJsonWhitespace = (character) => character === ' ' || character === '\t' || character === '\n' || character === '\r';
+const isJsonDelimiter = (character) => character === ',' || character === '}' || character === ']' || isJsonWhitespace(character);
+const skipJsonWhitespace = (text, start) => {
+    let position = start;
+    while (isJsonWhitespace(text[position])) {
+        position += 1;
+    }
+    return position;
+};
+const scanJsonString = (text, start) => {
+    let position = start + 1;
+    while (position < text.length) {
+        const character = text[position];
+        if (character === '\\') {
+            position += 2;
+            continue;
+        }
+        if (character === '"') {
+            return position + 1;
+        }
+        position += 1;
+    }
+    throw new Error('Failed to scan JSON string.');
+};
+const scanJsonContainer = (text, start) => {
+    let depth = 0;
+    let position = start;
+    while (position < text.length) {
+        const character = text[position];
+        if (character === '"') {
+            position = scanJsonString(text, position);
+            continue;
+        }
+        if (character === '{' || character === '[') {
+            depth += 1;
+        }
+        if (character === '}' || character === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                return position + 1;
+            }
+        }
+        position += 1;
+    }
+    throw new Error('Failed to scan JSON container.');
+};
+// Returns the position right after the value that starts at the given position.
+const scanJsonValue = (text, start) => {
+    const character = text[start];
+    if (character === '"') {
+        return scanJsonString(text, start);
+    }
+    if (character === '{' || character === '[') {
+        return scanJsonContainer(text, start);
+    }
+    let position = start;
+    while (position < text.length && !isJsonDelimiter(text[position])) {
+        position += 1;
+    }
+    return position;
+};
+export { scanJsonString, scanJsonValue, skipJsonWhitespace };

package/dist/ndjson/readNdJsonStream.d.ts

@@ -1,2 +1,8 @@
-declare const readNdJsonStream: (stream: ReadableStream<Uint8Array>, signal: AbortSignal, heartbeatTimeoutInMilliseconds?: number) => AsyncGenerator<Record<string, unknown>, void, void>;
+import type { StallGuard } from '../stall/StallGuard.js';
+interface NdJsonLine {
+    text: string;
+    value: Record<string, unknown>;
+}
+declare const readNdJsonStream: (stream: ReadableStream<Uint8Array>, signal: AbortSignal, stallGuard?: StallGuard) => AsyncGenerator<NdJsonLine, void, void>;
+export type { NdJsonLine };
 export { readNdJsonStream };

package/dist/ndjson/readNdJsonStream.js

@@ -1,27 +1,7 @@
-import { HeartbeatTimeoutError } from '../HeartbeatTimeoutError.js';
-const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMilliseconds) {
+const readNdJsonStream = async function* (stream, signal, stallGuard) {
     const reader = stream.getReader();
     const decoder = new TextDecoder('utf-8');
     let buffer = '';
-    let heartbeatTimer;
-    let hasHeartbeatTimedOut = false;
-    // The timer only runs while waiting for the next line, not while the caller
-    // handles a line, so a slow caller does not cause a heartbeat timeout.
-    const startHeartbeatTimer = () => {
-        if (heartbeatTimeoutInMilliseconds === undefined || heartbeatTimer !== undefined) {
-            return;
-        }
-        heartbeatTimer = setTimeout(() => {
-            hasHeartbeatTimedOut = true;
-            reader.cancel().catch(() => {
-                // Intentionally left blank.
-            });
-        }, heartbeatTimeoutInMilliseconds);
-    };
-    const stopHeartbeatTimer = () => {
-        clearTimeout(heartbeatTimer);
-        heartbeatTimer = undefined;
-    };
     const onAbort = () => {
         reader.cancel().catch(() => {
             // Intentionally left blank.
@@ -36,7 +16,9 @@ const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMill
     signal.addEventListener('abort', onAbort);
     try {
         while (!signal.aborted) {
-            startHeartbeatTimer();
+            // The clock only runs while waiting for the next chunk, not while the
+            // caller handles a line, so a slow caller does not cause a stall.
+            stallGuard?.restart();
             // biome-ignore lint/performance/noAwaitInLoops: Awaiting the result is fine here, although we are in a loop.
             const { done, value } = await reader.read();
             if (done) {
@@ -48,18 +30,15 @@ const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMill
                 const line = buffer.slice(0, index).trim();
                 buffer = buffer.slice(index + 1);
                 if (line) {
-                    stopHeartbeatTimer();
-                    yield JSON.parse(line);
+                    stallGuard?.pause();
+                    yield { text: line, value: JSON.parse(line) };
                 }
                 index = buffer.indexOf('\n');
             }
         }
-        if (hasHeartbeatTimedOut) {
-            throw new HeartbeatTimeoutError();
-        }
     }
     finally {
-        stopHeartbeatTimer();
+        stallGuard?.pause();
         signal.removeEventListener('abort', onAbort);
         await reader.cancel().catch(() => {
             // Intentionally left blank.

package/dist/stall/StallGuard.d.ts

@@ -0,0 +1,13 @@
+declare class StallGuard {
+    #private;
+    constructor(stallTimeout: number, callerSignal?: AbortSignal);
+    get signal(): AbortSignal;
+    send(url: string, init: RequestInit): Promise<Response>;
+    restart(): void;
+    pause(): void;
+    throwIfStalled(): void;
+    dispose({ abortRequest }: {
+        abortRequest: boolean;
+    }): void;
+}
+export { StallGuard };

package/dist/stall/StallGuard.js

@@ -0,0 +1,77 @@
+import { ConnectionStalledError } from '../ConnectionStalledError.js';
+import { createFetchTimeoutError } from './createFetchTimeoutError.js';
+// Ends a request once nothing arrives from the server for the stall timeout,
+// from sending the request until its end, including connecting and waiting
+// for the response headers. Everything that arrives restarts the clock, and
+// the clock stops while the caller handles an item of a stream. Aborting the
+// signal of the caller aborts the request as well.
+class StallGuard {
+    #stallTimeout;
+    #controller = new AbortController();
+    #callerSignal;
+    #phase = 'headers';
+    #stallError;
+    #timer;
+    #onCallerAbort = () => {
+        this.#controller.abort(this.#callerSignal?.reason);
+    };
+    constructor(stallTimeout, callerSignal) {
+        this.#stallTimeout = stallTimeout;
+        this.#callerSignal = callerSignal;
+        if (callerSignal?.aborted) {
+            this.#onCallerAbort();
+        }
+        else {
+            callerSignal?.addEventListener('abort', this.#onCallerAbort, { once: true });
+        }
+    }
+    // The signal of the request, which aborts once the request stalls or the
+    // caller aborts.
+    get signal() {
+        return this.#controller.signal;
+    }
+    // Sends the request with the signal of the guard. Once the headers of the
+    // response have arrived, the clock starts anew.
+    async send(url, init) {
+        const response = await fetch(url, { ...init, signal: this.#controller.signal });
+        this.#phase = 'body';
+        this.restart();
+        return response;
+    }
+    // Starts the clock, or starts it anew, since something arrived.
+    restart() {
+        if (this.#controller.signal.aborted) {
+            return;
+        }
+        // Starts a new timer rather than refreshing the running one, since the
+        // mocked timers of node:test do not move a refreshed timer.
+        this.pause();
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            this.#stallError = new ConnectionStalledError(this.#stallTimeout, {
+                cause: createFetchTimeoutError(this.#phase),
+            });
+            this.#controller.abort(this.#stallError);
+        }, this.#stallTimeout);
+    }
+    // Stops the clock, while the caller handles an item of a stream.
+    pause() {
+        clearTimeout(this.#timer);
+        this.#timer = undefined;
+    }
+    throwIfStalled() {
+        if (this.#stallError !== undefined) {
+            throw this.#stallError;
+        }
+    }
+    // Stops watching the request. Aborting it as well closes its connection,
+    // which a stream needs, since it may end before its body does.
+    dispose({ abortRequest }) {
+        this.pause();
+        this.#callerSignal?.removeEventListener('abort', this.#onCallerAbort);
+        if (abortRequest) {
+            this.#controller.abort();
+        }
+    }
+}
+export { StallGuard };

package/dist/stall/createFetchTimeoutError.d.ts

@@ -0,0 +1,2 @@
+declare const createFetchTimeoutError: (phase: 'headers' | 'body') => Error;
+export { createFetchTimeoutError };

package/dist/stall/createFetchTimeoutError.js

@@ -0,0 +1,16 @@
+// Creates an error like the one that the fetch built into Node.js gives as
+// the cause of its TypeError when it times out, with the same name, code, and
+// message, so that code that checks the code of the cause keeps working.
+const createFetchTimeoutError = (phase) => {
+    if (phase === 'headers') {
+        return Object.assign(new Error('Headers Timeout Error'), {
+            name: 'HeadersTimeoutError',
+            code: 'UND_ERR_HEADERS_TIMEOUT',
+        });
+    }
+    return Object.assign(new Error('Body Timeout Error'), {
+        name: 'BodyTimeoutError',
+        code: 'UND_ERR_BODY_TIMEOUT',
+    });
+};
+export { createFetchTimeoutError };

package/dist/stall/defaultStallTimeout.d.ts

@@ -0,0 +1,3 @@
+declare const defaultStallTimeout = 30000;
+declare const maximumStallTimeout = 2147483647;
+export { defaultStallTimeout, maximumStallTimeout };

package/dist/stall/defaultStallTimeout.js

@@ -0,0 +1,6 @@
+// A request fails once nothing arrives from the server for this many
+// milliseconds, unless the client is configured otherwise.
+const defaultStallTimeout = 30_000;
+// Node.js runs a timer for at most this many milliseconds.
+const maximumStallTimeout = 2_147_483_647;
+export { defaultStallTimeout, maximumStallTimeout };

package/dist/stall/formatDuration.d.ts

@@ -0,0 +1,2 @@
+declare const formatDuration: (milliseconds: number) => string;
+export { formatDuration };

package/dist/stall/formatDuration.js

@@ -0,0 +1,9 @@
+const millisecondsPerSecond = 1000;
+const formatDuration = (milliseconds) => {
+    if (milliseconds % millisecondsPerSecond === 0) {
+        const seconds = milliseconds / millisecondsPerSecond;
+        return `${seconds} ${seconds === 1 ? 'second' : 'seconds'}`;
+    }
+    return `${milliseconds} ${milliseconds === 1 ? 'millisecond' : 'milliseconds'}`;
+};
+export { formatDuration };

package/dist/stall/readResponseText.d.ts

@@ -0,0 +1,3 @@
+import type { StallGuard } from './StallGuard.js';
+declare const readResponseText: (response: Response, stallGuard: StallGuard) => Promise<string>;
+export { readResponseText };

package/dist/stall/readResponseText.js

@@ -0,0 +1,26 @@
+// Reads the body of a response as text, like response.text(), but restarts
+// the clock of the stall guard with every chunk that arrives.
+const readResponseText = async (response, stallGuard) => {
+    if (!response.body) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let text = '';
+    try {
+        stallGuard.restart();
+        let result = await reader.read();
+        while (!result.done) {
+            text += decoder.decode(result.value, { stream: true });
+            stallGuard.restart();
+            // biome-ignore lint/performance/noAwaitInLoops: Awaiting the result is fine here, although we are in a loop.
+            result = await reader.read();
+        }
+        text += decoder.decode();
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return text;
+};
+export { readResponseText };

package/dist/stall/runWithStallGuard.d.ts

@@ -0,0 +1,6 @@
+import { StallGuard } from './StallGuard.js';
+declare const runWithStallGuard: <TResult>({ stallTimeout, signal }: {
+    stallTimeout: number;
+    signal?: AbortSignal;
+}, run: (stallGuard: StallGuard) => Promise<TResult>) => Promise<TResult>;
+export { runWithStallGuard };

package/dist/stall/runWithStallGuard.js

@@ -0,0 +1,18 @@
+import { StallGuard } from './StallGuard.js';
+// Runs a request that is not a stream under a stall guard. If the request
+// stalls, it fails with the error of the stall, whatever fetch throws then.
+const runWithStallGuard = async ({ stallTimeout, signal }, run) => {
+    const stallGuard = new StallGuard(stallTimeout, signal);
+    try {
+        stallGuard.restart();
+        return await run(stallGuard);
+    }
+    catch (error) {
+        stallGuard.throwIfStalled();
+        throw error;
+    }
+    finally {
+        stallGuard.dispose({ abortRequest: false });
+    }
+};
+export { runWithStallGuard };

package/dist/stall/streamWithStallGuard.d.ts

@@ -0,0 +1,6 @@
+import { StallGuard } from './StallGuard.js';
+declare const streamWithStallGuard: <TItem>({ stallTimeout, signal }: {
+    stallTimeout: number;
+    signal?: AbortSignal;
+}, stream: (stallGuard: StallGuard) => AsyncGenerator<TItem, void, void>) => AsyncGenerator<TItem, void, void>;
+export { streamWithStallGuard };

package/dist/stall/streamWithStallGuard.js

@@ -0,0 +1,25 @@
+import { isAbortError } from '../http/isAbortError.js';
+import { StallGuard } from './StallGuard.js';
+// Runs a request that is a stream under a stall guard. If the request stalls,
+// the stream fails with the error of the stall, whatever fetch throws then. If
+// the caller aborts, the stream ends without an error. Ending the stream early
+// closes the connection of the request.
+const streamWithStallGuard = async function* ({ stallTimeout, signal }, stream) {
+    const stallGuard = new StallGuard(stallTimeout, signal);
+    try {
+        stallGuard.restart();
+        yield* stream(stallGuard);
+        stallGuard.throwIfStalled();
+    }
+    catch (error) {
+        stallGuard.throwIfStalled();
+        if (isAbortError(error)) {
+            return;
+        }
+        throw error;
+    }
+    finally {
+        stallGuard.dispose({ abortRequest: true });
+    }
+};
+export { streamWithStallGuard };

package/dist/v1/V1Transport.d.ts

@@ -0,0 +1,23 @@
+import type { Event } from '../Event.js';
+import type { EventCandidate } from '../EventCandidate.js';
+import type { EventType } from '../EventType.js';
+import type { ObserveEventsOptions } from '../ObserveEventsOptions.js';
+import type { Precondition } from '../Precondition.js';
+import type { ReadEventsOptions } from '../ReadEventsOptions.js';
+import type { ReadSubjectsOptions } from '../ReadSubjectsOptions.js';
+import type { Transport, TransportOptions } from '../Transport.js';
+declare class V1Transport implements Transport {
+    #private;
+    constructor({ url, apiToken, stallTimeout }: TransportOptions);
+    ping(signal?: AbortSignal): Promise<void>;
+    verifyApiToken(signal?: AbortSignal): Promise<void>;
+    writeEvents(events: EventCandidate[], preconditions: Precondition[], signal?: AbortSignal): Promise<Event[]>;
+    readEvents(subject: string, options: ReadEventsOptions, signal?: AbortSignal): AsyncGenerator<Event, void, void>;
+    runEventQlQuery(query: string, signal?: AbortSignal): AsyncGenerator<unknown, void, void>;
+    observeEvents(subject: string, options: ObserveEventsOptions, signal?: AbortSignal): AsyncGenerator<Event, void, void>;
+    registerEventSchema(eventType: string, schema: Record<string, unknown>, signal?: AbortSignal): Promise<void>;
+    readSubjects(subject: string, { recursive }: ReadSubjectsOptions, signal?: AbortSignal): AsyncGenerator<string, void, void>;
+    readEventType(eventType: string, signal?: AbortSignal): Promise<EventType>;
+    readEventTypes(signal?: AbortSignal): AsyncGenerator<EventType, void, void>;
+}
+export { V1Transport };