applesauce-core 0.9.0 → 0.11.0

package/dist/queries/channels.d.ts

@@ -0,0 +1,11 @@
+import { Query } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { ChannelMetadataContent } from "../helpers/channels.js";
+/** A query that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** A query that returns all messages in a channel */
+export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;
+/** A query that returns the latest parsed metadata */
+export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
+/** A query that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;

package/dist/queries/channels.js

@@ -0,0 +1,73 @@
+import { safeParse } from "applesauce-core/helpers/json";
+import { kinds } from "nostr-tools";
+import { map } from "rxjs";
+import { getChannelMetadataContent } from "../helpers/channels.js";
+/** A query that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenQuery(channel, authors = []) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const hidden = new Map();
+            return events
+                .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .pipe(map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "e" && tag[1])
+                        hidden.set(tag[1], reason ?? "");
+                }
+                return hidden;
+            }));
+        },
+    };
+}
+/** A query that returns all messages in a channel */
+export function ChannelMessagesQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
+    };
+}
+/** A query that returns the latest parsed metadata */
+export function ChannelMetadataQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const filters = [
+                { ids: [channel.id] },
+                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+            ];
+            let latest = channel;
+            return events.filters(filters).pipe(map((event) => {
+                try {
+                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                        latest = event;
+                    }
+                    return getChannelMetadataContent(latest);
+                }
+                catch (error) {
+                    return undefined;
+                }
+            }));
+        },
+    };
+}
+/** A query that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedQuery(channel, authors = []) {
+    return {
+        key: channel.id + authors.join(","),
+        run: (events) => {
+            const muted = new Map();
+            return events
+                .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .pipe(map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "p" && tag[1])
+                        muted.set(tag[1], reason ?? "");
+                }
+                return muted;
+            }));
+        },
+    };
+}

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/contacts.d.ts

@@ -0,0 +1,3 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Query } from "../query-store/index.js";
+export declare function UserContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;

package/dist/queries/contacts.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isPTag, processTags } from "../helpers/tags.js";
+import { getProfilePointerFromPTag } from "../helpers/pointers.js";
+export function UserContactsQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(kinds.Contacts, pubkey)
+            .pipe(map((event) => event && processTags(event.tags.filter(isPTag), getProfilePointerFromPTag))),
+    };
+}

package/dist/queries/index.d.ts

@@ -1,6 +1,13 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./channels.js";
+export * from "./comments.js";
+export * from "./contacts.js";
 export * from "./mailboxes.js";
+export * from "./mutes.js";
+export * from "./pins.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

@@ -1,6 +1,13 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./channels.js";
+export * from "./comments.js";
+export * from "./contacts.js";
 export * from "./mailboxes.js";
+export * from "./mutes.js";
+export * from "./pins.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

@@ -1,4 +1,5 @@
 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[];

package/dist/queries/mailboxes.js

@@ -1,6 +1,7 @@
 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,

package/dist/queries/mutes.d.ts

@@ -0,0 +1,8 @@
+import { Mutes } from "../helpers/mutes.js";
+import { Query } from "../query-store/index.js";
+export declare function UserMuteQuery(pubkey: string): Query<Mutes | undefined>;
+export declare function UserHiddenMuteQuery(pubkey: string): Query<(Mutes & {
+    locked: false;
+}) | {
+    locked: true;
+} | undefined>;

package/dist/queries/mutes.js

@@ -0,0 +1,23 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getHiddenMutedThings, getMutedThings } from "../helpers/mutes.js";
+import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
+export function UserMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
+    };
+}
+export function UserHiddenMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const muted = getHiddenMutedThings(event);
+            if (isHiddenTagsLocked(event) || !muted)
+                return { locked: true };
+            return { locked: false, ...muted };
+        })),
+    };
+}

package/dist/queries/pins.d.ts

@@ -0,0 +1,3 @@
+import { Query } from "applesauce-core";
+import { EventPointer } from "nostr-tools/nip19";
+export declare function UserPinnedQuery(pubkey: string): Query<EventPointer[] | undefined>;

package/dist/queries/pins.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isETag, processTags } from "../helpers/tags.js";
+import { getEventPointerFromETag } from "../helpers/pointers.js";
+export function UserPinnedQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(kinds.Pinlist, pubkey)
+            .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag))),
+    };
+}

package/dist/queries/profile.d.ts

@@ -1,3 +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

@@ -1,6 +1,7 @@
 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,

package/dist/queries/reactions.d.ts

@@ -1,4 +1,4 @@
 import { NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
-/** Creates a query that returns all reactions to an event (supports replaceable events) */
+/** 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

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
-/** Creates a query that returns all reactions to an event (supports replaceable events) */
+/** A query that returns all reactions to an event (supports replaceable events) */
 export function ReactionsQuery(event) {
     return {
         key: getEventUID(event),

package/dist/queries/simple.d.ts

@@ -1,16 +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(uid: string): Query<NostrEvent | 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(uids: string[]): Query<Map<string, NostrEvent>>;
+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[]): Query<NostrEvent[]>;
+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<Map<string, NostrEvent>>;
+}[]): Query<Record<string, NostrEvent>>;

package/dist/queries/simple.js

@@ -1,17 +1,17 @@
-import stringify from "json-stringify-deterministic";
+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(uid) {
+export function SingleEventQuery(id) {
     return {
-        key: uid,
-        run: (events) => events.event(uid),
+        key: id,
+        run: (events) => events.event(id),
     };
 }
 /** Creates a Query that returns a multiple events in a map */
-export function MultipleEventsQuery(uids) {
+export function MultipleEventsQuery(ids) {
     return {
-        key: uids.join(","),
-        run: (events) => events.events(uids),
+        key: ids.join(","),
+        run: (events) => events.events(ids),
     };
 }
 /** Creates a Query returning the latest version of a replaceable event */
@@ -22,17 +22,17 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters) {
+export function TimelineQuery(filters, keepOldVersions) {
+    filters = Array.isArray(filters) ? filters : [filters];
     return {
-        key: stringify(filters),
-        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+        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) {
-    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
     return {
-        key: stringify(pointers),
-        run: (events) => events.events(cords),
+        key: hash_sum(pointers),
+        run: (events) => events.replaceableSet(pointers),
     };
 }

package/dist/queries/thread.d.ts

@@ -21,3 +21,5 @@ 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

@@ -1,8 +1,10 @@
 import { kinds } from "nostr-tools";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
-import { getNip10References } from "../helpers/threading.js";
-import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
-import { getEventUID } from "../helpers/event.js";
+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],
 };
@@ -32,7 +34,7 @@ export function ThreadQuery(root, opts) {
     }
     return {
         key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.stream([rootFilter, replyFilter]).pipe(map((event) => {
+        run: (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
             if (!items.has(getEventUID(event))) {
                 const refs = getNip10References(event);
                 const replies = parentReferences.get(getEventUID(event)) || new Set();
@@ -64,3 +66,27 @@ export function ThreadQuery(root, opts) {
         })),
     };
 }
+/** 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/user-status.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { UserStatusPointer } from "../helpers/user-status.js";
+import { Query } from "../query-store/index.js";
+export type UserStatus = UserStatusPointer & {
+    event: NostrEvent;
+    content: string;
+};
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export declare function UserStatusQuery(pubkey: string, type?: string): Query<UserStatus | undefined | null>;
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export declare function UserStatusesQuery(pubkey: string): Query<Record<string, UserStatus>>;

package/dist/queries/user-status.js

@@ -0,0 +1,39 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs";
+import { getUserStatusPointer } from "../helpers/user-status.js";
+import { getReplaceableIdentifier } from "../helpers/event.js";
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export function UserStatusQuery(pubkey, type = "general") {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const pointer = getUserStatusPointer(event);
+            if (!pointer)
+                return null;
+            return {
+                ...pointer,
+                event,
+                content: event.content,
+            };
+        })),
+    };
+}
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export function UserStatusesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
+            return events.reduce((dir, event) => {
+                try {
+                    const d = getReplaceableIdentifier(event);
+                    return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+                }
+                catch (error) {
+                    return dir;
+                }
+            }, {});
+        })),
+    };
+}

package/dist/queries/zaps.d.ts

@@ -1,4 +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

@@ -2,6 +2,7 @@ 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),

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

@@ -1,47 +1 @@
-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> = {
-    key: string;
-    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<Observable<any> | BehaviorSubject<any>>;
-    /** Creates a cached query */
-    runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
-        key: string;
-        run: (events: EventStore, store: QueryStore) => Observable<T>;
-    }): (...args: Args) => Observable<T>;
-    /** Returns a single event */
-    event(id: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Returns a single event */
-    events(ids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
-    /** Returns the latest version of a replaceable event */
-    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Returns a directory of events by their UID */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Map<string, import("nostr-tools").Event>>;
-    /** Returns an array of events that match the filter */
-    timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
-    /** Returns the parsed profile (0) for a pubkey */
-    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Returns all reactions for an event (supports replaceable events) */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Returns the parsed relay list (10002) for the pubkey */
-    mailboxes(pubkey: string): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
-}
-export { Queries };
+export * from "./query-store.js";

package/dist/query-store/index.js

@@ -1,60 +1 @@
-import { LRU } from "../helpers/lru.js";
-import * as Queries from "../queries/index.js";
-import { shareLatestValue } from "../observable/share-latest-value.js";
-export class QueryStore {
-    static Queries = Queries;
-    store;
-    constructor(store) {
-        this.store = store;
-    }
-    queries = new LRU();
-    /** Creates a cached query */
-    runQuery(queryConstructor) {
-        return (...args) => {
-            const query = queryConstructor(...args);
-            const key = `${queryConstructor.name}|${query.key}`;
-            if (!this.queries.has(key)) {
-                const observable = query.run(this.store, this).pipe(shareLatestValue());
-                this.queries.set(key, observable);
-                return observable;
-            }
-            return this.queries.get(key);
-        };
-    }
-    /** Returns a single event */
-    event(id) {
-        return this.runQuery(Queries.SingleEventQuery)(id);
-    }
-    /** Returns a single event */
-    events(ids) {
-        return this.runQuery(Queries.MultipleEventsQuery)(ids);
-    }
-    /** Returns the latest version of a replaceable event */
-    replaceable(kind, pubkey, d) {
-        return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
-    }
-    /** Returns a directory of events by their UID */
-    replaceableSet(pointers) {
-        return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
-    }
-    /** Returns an array of events that match the filter */
-    timeline(filters) {
-        return this.runQuery(Queries.TimelineQuery)(filters);
-    }
-    /** Returns the parsed profile (0) for a pubkey */
-    profile(pubkey) {
-        return this.runQuery(Queries.ProfileQuery)(pubkey);
-    }
-    /** Returns all reactions for an event (supports replaceable events) */
-    reactions(event) {
-        return this.runQuery(Queries.ReactionsQuery)(event);
-    }
-    /** Returns the parsed relay list (10002) for the pubkey */
-    mailboxes(pubkey) {
-        return this.runQuery(Queries.MailboxesQuery)(pubkey);
-    }
-    thread(root) {
-        return this.runQuery(Queries.ThreadQuery)(root);
-    }
-}
-export { Queries };
+export * from "./query-store.js";

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

@@ -0,0 +1,51 @@
+import { Observable } from "rxjs";
+import { Filter, NostrEvent } from "nostr-tools";
+import type { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { EventStore } from "../event-store/event-store.js";
+import * as Queries from "../queries/index.js";
+export type Query<T extends unknown> = {
+    /** A unique key for this query. this is used to detect duplicate queries */
+    key: string;
+    /** 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);
+    /** A directory of all active queries */
+    queries: Map<QueryConstructor<any, any[]>, Map<string, Observable<any>>>;
+    /** How long a query should be kept "warm" while nothing is subscribed to it */
+    queryKeepWarmTimeout: number;
+    /** Creates a cached query */
+    createQuery<T extends unknown, Args extends Array<any>>(queryConstructor: QueryConstructor<T, Args>, ...args: Args): Observable<T | undefined>;
+    /** Creates a query and waits for the next value */
+    executeQuery<T extends unknown, Args extends Array<any>>(queryConstructor: QueryConstructor<T, Args>, ...args: Args): Promise<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> | undefined>;
+    /** 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> | undefined>;
+    /** Creates a TimelineQuery */
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[] | undefined>;
+    /** Creates a ProfileQuery */
+    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Creates a ReactionsQuery */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[] | undefined>;
+    /** Creates a MailboxesQuery */
+    mailboxes(pubkey: string): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    /** Creates a ThreadQuery */
+    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread | undefined>;
+}
+export { Queries };