applesauce-core 0.0.0-next-20250123214405 → 0.0.0-next-20250124150519

package/dist/helpers/url.js

@@ -0,0 +1,30 @@
+export const convertToUrl = (url) => (url instanceof URL ? url : new URL(url));
+export const getURLFilename = (url) => url.pathname.split("/").pop()?.toLocaleLowerCase() || url.searchParams.get("filename")?.toLocaleLowerCase();
+export const IMAGE_EXT = [".svg", ".gif", ".png", ".jpg", ".jpeg", ".webp", ".avif"];
+export const VIDEO_EXT = [".mp4", ".mkv", ".webm", ".mov"];
+export const STREAM_EXT = [".m3u8"];
+export const AUDIO_EXT = [".mp3", ".wav", ".ogg", ".aac"];
+/** Checks if a url is a image URL */
+export function isImageURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && IMAGE_EXT.some((ext) => filename.endsWith(ext));
+}
+/** Checks if a url is a video URL */
+export function isVideoURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && VIDEO_EXT.some((ext) => filename.endsWith(ext));
+}
+/** Checks if a url is a stream URL */
+export function isStreamURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && STREAM_EXT.some((ext) => filename.endsWith(ext));
+}
+/** Checks if a url is a audio URL */
+export function isAudioURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && AUDIO_EXT.some((ext) => filename.endsWith(ext));
+}

package/dist/helpers/zap.d.ts

@@ -0,0 +1,39 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ZapRequestSymbol: unique symbol;
+export declare const ZapFromSymbol: unique symbol;
+export declare const ZapInvoiceSymbol: unique symbol;
+export declare const ZapEventPointerSymbol: unique symbol;
+export declare const ZapAddressPointerSymbol: unique symbol;
+/** Returns the senders pubkey */
+export declare function getZapSender(zap: NostrEvent): string;
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
+export declare function getZapRecipient(zap: NostrEvent): string;
+/** Returns the parsed bolt11 invoice */
+export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+/** Gets the AddressPointer that was zapped */
+export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+/** Gets the EventPointer that was zapped */
+export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
+/** Gets the preimage for the bolt11 invoice */
+export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
+export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
+export declare function isValidZap(zap?: NostrEvent): boolean;
+export type ZapSplit = {
+    pubkey: string;
+    percent: number;
+    weight: number;
+    relay?: string;
+};
+/** Returns the zap splits for an event */
+export declare function getZapSplits(event: NostrEvent): ZapSplit[] | undefined;

package/dist/helpers/zap.js

@@ -0,0 +1,95 @@
+import { kinds, nip57 } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event.js";
+import { isATag, isETag } from "./tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { parseBolt11 } from "./bolt11.js";
+export const ZapRequestSymbol = Symbol.for("zap-request");
+export const ZapFromSymbol = Symbol.for("zap-from");
+export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
+export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
+export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+/** Returns the senders pubkey */
+export function getZapSender(zap) {
+    return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+}
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
+export function getZapRecipient(zap) {
+    const recipient = getTagValue(zap, "p");
+    if (!recipient)
+        throw new Error("Missing recipient");
+    return recipient;
+}
+/** Returns the parsed bolt11 invoice */
+export function getZapPayment(zap) {
+    return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
+        const bolt11 = getTagValue(zap, "bolt11");
+        return bolt11 ? parseBolt11(bolt11) : undefined;
+    });
+}
+/** Gets the AddressPointer that was zapped */
+export function getZapAddressPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
+        const a = zap.tags.find(isATag);
+        return a ? getAddressPointerFromATag(a) : null;
+    });
+}
+/** Gets the EventPointer that was zapped */
+export function getZapEventPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
+        const e = zap.tags.find(isETag);
+        return e ? getEventPointerFromETag(e) : null;
+    });
+}
+/** Gets the preimage for the bolt11 invoice */
+export function getZapPreimage(zap) {
+    return getTagValue(zap, "preimage");
+}
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
+export function getZapRequest(zap) {
+    return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
+        const description = getTagValue(zap, "description");
+        if (!description)
+            throw new Error("Missing description tag");
+        const error = nip57.validateZapRequest(description);
+        if (error)
+            throw new Error(error);
+        return JSON.parse(description);
+    });
+}
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
+export function isValidZap(zap) {
+    if (!zap)
+        return false;
+    if (zap.kind !== kinds.Zap)
+        return false;
+    try {
+        getZapRequest(zap);
+        getZapRecipient(zap);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/** Returns the zap splits for an event */
+export function getZapSplits(event) {
+    const tags = event.tags.filter((t) => t[0] === "zap" && t[1] && t[3]);
+    if (tags.length > 0) {
+        const targets = tags
+            .map((t) => ({ pubkey: t[1], relay: t[2], weight: parseFloat(t[3]) }))
+            .filter((p) => Number.isFinite(p.weight));
+        const total = targets.reduce((v, p) => v + p.weight, 0);
+        return targets.map((p) => ({ ...p, percent: p.weight / total }));
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./event-store/index.js";
+export * from "./query-store/index.js";
+export * as Helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";
+export * from "./logger.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./event-store/index.js";
+export * from "./query-store/index.js";
+export * as Helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";
+export * from "./logger.js";

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import debug from "debug";
+export declare const logger: debug.Debugger;

package/dist/logger.js

@@ -0,0 +1,2 @@
+import debug from "debug";
+export const logger = debug("applesauce");

package/dist/observable/get-value.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from "rxjs";
+/** Subscribes and returns the observables current or next value */
+export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-value.js

@@ -0,0 +1,14 @@
+import { BehaviorSubject } from "rxjs";
+/** Subscribes and returns the observables current or next value */
+export function getValue(observable) {
+    if (observable instanceof BehaviorSubject)
+        return observable.value;
+    if (Reflect.has(observable, "value"))
+        return Reflect.get(observable, "value");
+    return new Promise((res) => {
+        const sub = observable.subscribe((v) => {
+            res(v);
+            sub.unsubscribe();
+        });
+    });
+}

package/dist/observable/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./get-value.js";
+export * from "./share-latest-value.js";

package/dist/observable/index.js

@@ -0,0 +1,2 @@
+export * from "./get-value.js";
+export * from "./share-latest-value.js";

package/dist/observable/share-latest-value.d.ts

@@ -0,0 +1,8 @@
+import { Observable, ShareConfig } from "rxjs";
+/**
+ * Creates an operator that adds a 'value' property and multiplexes the source
+ * @param config Optional ShareConfig for customizing sharing behavior
+ */
+export declare function shareLatestValue<T>(config?: ShareConfig<T>): (source: Observable<T>) => Observable<T> & {
+    value: T | undefined;
+};

package/dist/observable/share-latest-value.js

@@ -0,0 +1,21 @@
+import { share } from "rxjs";
+import { tap } from "rxjs/operators";
+/**
+ * Creates an operator that adds a 'value' property and multiplexes the source
+ * @param config Optional ShareConfig for customizing sharing behavior
+ */
+export function shareLatestValue(config = {}) {
+    return (source) => {
+        // Create storage for latest value
+        let latestValue = undefined;
+        // Create shared source with value tracking
+        const shared$ = source.pipe(tap((value) => {
+            latestValue = value;
+        }), share(config));
+        // Add value property
+        Object.defineProperty(shared$, "value", {
+            get: () => latestValue,
+        });
+        return shared$;
+    };
+}

package/dist/promise/deferred.d.ts

@@ -0,0 +1,6 @@
+export type Deferred<T> = Promise<T> & {
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+/** Creates a controlled promise */
+export declare function createDefer<T>(): Deferred<T>;

package/dist/promise/deferred.js

@@ -0,0 +1,15 @@
+/** Creates a controlled promise */
+export function createDefer() {
+    let _resolve;
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        // @ts-ignore
+        _resolve = resolve;
+        _reject = reject;
+    });
+    // @ts-ignore
+    promise.resolve = _resolve;
+    // @ts-ignore
+    promise.reject = _reject;
+    return promise;
+}

package/dist/promise/index.d.ts

@@ -0,0 +1 @@
+export * from "./deferred.js";

package/dist/promise/index.js

@@ -0,0 +1 @@
+export * from "./deferred.js";

package/dist/queries/comments.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** Returns all NIP-22 comment replies for the event */
+export declare function CommentsQuery(parent: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/comments.js

@@ -0,0 +1,14 @@
+import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+/** Returns all NIP-22 comment replies for the event */
+export function CommentsQuery(parent) {
+    return {
+        key: `${getEventUID(parent)}-comments`,
+        run: (events) => {
+            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+            if (isParameterizedReplaceableKind(parent.kind))
+                filter["#a"] = [getEventUID(parent)];
+            return events.timeline(filter);
+        },
+    };
+}

package/dist/queries/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./comments.js";
+export * from "./mailboxes.js";
+export * from "./profile.js";
+export * from "./reactions.js";
+export * from "./simple.js";
+export * from "./thread.js";
+export * from "./zaps.js";

package/dist/queries/index.js

@@ -0,0 +1,7 @@
+export * from "./comments.js";
+export * from "./mailboxes.js";
+export * from "./profile.js";
+export * from "./reactions.js";
+export * from "./simple.js";
+export * from "./thread.js";
+export * from "./zaps.js";

package/dist/queries/mailboxes.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "../query-store/index.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
+export declare function MailboxesQuery(pubkey: string): Query<{
+    inboxes: string[];
+    outboxes: string[];
+} | undefined>;

package/dist/queries/mailboxes.js

@@ -0,0 +1,13 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
+export function MailboxesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+            inboxes: getInboxes(event),
+            outboxes: getOutboxes(event),
+        })),
+    };
+}

package/dist/queries/profile.d.ts

@@ -0,0 +1,4 @@
+import { ProfileContent } from "../helpers/profile.js";
+import { Query } from "../query-store/index.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
+export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/queries/profile.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { filter, map } from "rxjs/operators";
+import { getProfileContent, isValidProfile } from "../helpers/profile.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
+export function ProfileQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => {
+            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
+        },
+    };
+}

package/dist/queries/reactions.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** A query that returns all reactions to an event (supports replaceable events) */
+export declare function ReactionsQuery(event: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/reactions.js

@@ -0,0 +1,19 @@
+import { kinds } from "nostr-tools";
+import { getEventUID, isReplaceable } from "../helpers/event.js";
+/** A query that returns all reactions to an event (supports replaceable events) */
+export function ReactionsQuery(event) {
+    return {
+        key: getEventUID(event),
+        run: (events) => events.timeline(isReplaceable(event.kind)
+            ? [
+                { kinds: [kinds.Reaction], "#e": [event.id] },
+                { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+            ]
+            : [
+                {
+                    kinds: [kinds.Reaction],
+                    "#e": [event.id],
+                },
+            ]),
+    };
+}

package/dist/queries/simple.d.ts

@@ -0,0 +1,16 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** Creates a Query that returns a single event or undefined */
+export declare function SingleEventQuery(id: string): Query<NostrEvent | undefined>;
+/** Creates a Query that returns a multiple events in a map */
+export declare function MultipleEventsQuery(ids: string[]): Query<Record<string, NostrEvent>>;
+/** Creates a Query returning the latest version of a replaceable event */
+export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
+/** Creates a Query that returns an array of sorted events matching the filters */
+export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
+/** Creates a Query that returns a directory of events by their UID */
+export declare function ReplaceableSetQuery(pointers: {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+}[]): Query<Record<string, NostrEvent>>;

package/dist/queries/simple.js

@@ -0,0 +1,38 @@
+import hash_sum from "hash-sum";
+import { getReplaceableUID } from "../helpers/event.js";
+/** Creates a Query that returns a single event or undefined */
+export function SingleEventQuery(id) {
+    return {
+        key: id,
+        run: (events) => events.event(id),
+    };
+}
+/** Creates a Query that returns a multiple events in a map */
+export function MultipleEventsQuery(ids) {
+    return {
+        key: ids.join(","),
+        run: (events) => events.events(ids),
+    };
+}
+/** Creates a Query returning the latest version of a replaceable event */
+export function ReplaceableQuery(kind, pubkey, d) {
+    return {
+        key: getReplaceableUID(kind, pubkey, d),
+        run: (events) => events.replaceable(kind, pubkey, d),
+    };
+}
+/** Creates a Query that returns an array of sorted events matching the filters */
+export function TimelineQuery(filters, keepOldVersions) {
+    filters = Array.isArray(filters) ? filters : [filters];
+    return {
+        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
+        run: (events) => events.timeline(filters, keepOldVersions),
+    };
+}
+/** Creates a Query that returns a directory of events by their UID */
+export function ReplaceableSetQuery(pointers) {
+    return {
+        key: hash_sum(pointers),
+        run: (events) => events.replaceableSet(pointers),
+    };
+}

package/dist/queries/thread.d.ts

@@ -0,0 +1,25 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { Query } from "../query-store/index.js";
+import { ThreadReferences } from "../helpers/threading.js";
+export type Thread = {
+    root?: ThreadItem;
+    all: Map<string, ThreadItem>;
+};
+export type ThreadItem = {
+    /** underlying nostr event */
+    event: NostrEvent;
+    refs: ThreadReferences;
+    /** the thread root, according to this event */
+    root?: ThreadItem;
+    /** the parent event this is replying to */
+    parent?: ThreadItem;
+    /** direct child replies */
+    replies: Set<ThreadItem>;
+};
+export type ThreadQueryOptions = {
+    kinds?: number[];
+};
+export declare function ThreadQuery(root: string | AddressPointer | EventPointer, opts?: ThreadQueryOptions): Query<Thread>;
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;

package/dist/queries/thread.js

@@ -0,0 +1,92 @@
+import { kinds } from "nostr-tools";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { map } from "rxjs/operators";
+import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
+import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
+import { getEventUID, getReplaceableUID, getTagValue, isEvent } from "../helpers/event.js";
+import { COMMENT_KIND } from "../helpers/comment.js";
+const defaultOptions = {
+    kinds: [kinds.ShortTextNote],
+};
+export function ThreadQuery(root, opts) {
+    const parentReferences = new Map();
+    const items = new Map();
+    const { kinds } = { ...defaultOptions, ...opts };
+    let rootUID = "";
+    const rootFilter = {};
+    const replyFilter = { kinds };
+    if (isAddressPointer(root)) {
+        rootUID = getCoordinateFromAddressPointer(root);
+        rootFilter.kinds = [root.kind];
+        rootFilter.authors = [root.pubkey];
+        rootFilter["#d"] = [root.identifier];
+        replyFilter["#a"] = [rootUID];
+    }
+    else if (typeof root === "string") {
+        rootUID = root;
+        rootFilter.ids = [root];
+        replyFilter["#e"] = [root];
+    }
+    else {
+        rootUID = root.id;
+        rootFilter.ids = [root.id];
+        replyFilter["#e"] = [root.id];
+    }
+    return {
+        key: `${rootUID}-${kinds.join(",")}`,
+        run: (events) => events.stream([rootFilter, replyFilter]).pipe(map((event) => {
+            if (!items.has(getEventUID(event))) {
+                const refs = getNip10References(event);
+                const replies = parentReferences.get(getEventUID(event)) || new Set();
+                const item = { event, refs, replies };
+                for (const child of replies) {
+                    child.parent = item;
+                }
+                // add item to parent
+                if (refs.reply?.e || refs.reply?.a) {
+                    let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
+                    item.parent = items.get(uid);
+                    if (item.parent) {
+                        item.parent.replies.add(item);
+                    }
+                    else {
+                        // parent isn't created yet, store ref for later
+                        let set = parentReferences.get(uid);
+                        if (!set) {
+                            set = new Set();
+                            parentReferences.set(uid, set);
+                        }
+                        set.add(item);
+                    }
+                }
+                // add item to map
+                items.set(getEventUID(event), item);
+            }
+            return { root: items.get(rootUID), all: items };
+        })),
+    };
+}
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export function RepliesQuery(event, overrideKinds) {
+    return {
+        key: getEventUID(event),
+        run: (events) => {
+            const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
+            const filter = { kinds };
+            if (isEvent(parent) || isEventPointer(event))
+                filter["#e"] = [event.id];
+            const address = isParameterizedReplaceableKind(event.kind)
+                ? getReplaceableUID(event.kind, event.pubkey, getTagValue(event, "d"))
+                : undefined;
+            if (address) {
+                filter["#a"] = [address];
+            }
+            return events.timeline(filter).pipe(map((events) => {
+                return events.filter((e) => {
+                    const refs = interpretThreadTags(e.tags);
+                    return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
+                });
+            }));
+        },
+    };
+}

package/dist/queries/zaps.d.ts

@@ -0,0 +1,5 @@
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** A query that gets all zap events for an event */
+export declare function EventZapsQuery(id: string | EventPointer | AddressPointer): Query<NostrEvent[]>;

package/dist/queries/zaps.js

@@ -0,0 +1,21 @@
+import { map } from "rxjs";
+import { kinds } from "nostr-tools";
+import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
+import { isValidZap } from "../helpers/zap.js";
+/** A query that gets all zap events for an event */
+export function EventZapsQuery(id) {
+    return {
+        key: JSON.stringify(id),
+        run: (events) => {
+            if (isAddressPointer(id)) {
+                return events
+                    .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
+                    .pipe(map((events) => events.filter(isValidZap)));
+            }
+            else {
+                id = typeof id === "string" ? id : id.id;
+                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
+            }
+        },
+    };
+}

package/dist/query-store/index.d.ts

@@ -0,0 +1,57 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { Filter, NostrEvent } from "nostr-tools";
+import { EventStore } from "../event-store/event-store.js";
+import { LRU } from "../helpers/lru.js";
+import * as Queries from "../queries/index.js";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export type Query<T extends unknown> = {
+    /**
+     * A unique key for this query. this is used to detect duplicate queries
+     */
+    key: string;
+    /** The args array this query was created with. This is mostly for debugging */
+    args?: Array<any>;
+    /**
+     * The meat of the query, this should return an Observables that subscribes to the eventStore in some way
+     */
+    run: (events: EventStore, store: QueryStore) => Observable<T>;
+};
+export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
+export declare class QueryStore {
+    static Queries: typeof Queries;
+    store: EventStore;
+    constructor(store: EventStore);
+    queries: LRU<Query<any>>;
+    observables: WeakMap<Query<any>, Observable<any> | BehaviorSubject<any>>;
+    /** Creates a cached query */
+    createQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
+        key: string;
+        run: (events: EventStore, store: QueryStore) => Observable<T>;
+    }, ...args: Args): Observable<T>;
+    /** Creates a SingleEventQuery */
+    event(id: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates a MultipleEventsQuery */
+    events(ids: string[]): Observable<Record<string, import("nostr-tools").Event>>;
+    /** Creates a ReplaceableQuery */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates a ReplaceableSetQuery */
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, import("nostr-tools").Event>>;
+    /** Creates a TimelineQuery */
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[]>;
+    /** Creates a ProfileQuery */
+    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Creates a ReactionsQuery */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Creates a MailboxesQuery */
+    mailboxes(pubkey: string): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    /** Creates a ThreadQuery */
+    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
+}
+export { Queries };