applesauce-core 0.0.0-concord-20260710175615

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# applesauce-core
+
+Applesauce is a collection of utilities for building reactive nostr applications. The core package provides protocol-level functionality including an in-memory event database, generic event utilities, and basic reactive models.
+
+## Key Components
+
+- **Helpers**: Core utility methods for parsing and extracting data from nostr events
+- **EventStore**: In-memory database for storing and subscribing to nostr events
+- **Helpers**: Core protocol-level utility methods for working with events, tags, filters, and pointers
+- **Models**: Generic models for common nostr data patterns (profiles, reactions, zaps, etc.)
+- **Observable**: RxJS utilities for reactive programming
+
+> **Note**: For NIP-specific helpers and models (NIP-10 threading, NIP-22 comments, NIP-53 streams, etc.), see the [`applesauce-common`](../common/README.md) package.
+
+## Documentation
+
+For detailed documentation and guides, visit:
+
+- [Getting Started](https://applesauce.build/introduction/getting-started)
+- [API Reference](https://applesauce.build/typedoc/)
+
+## Example
+
+```js
+import { EventStore } from "applesauce-core";
+import { ProfileModel, TimelineModel } from "applesauce-core/models";
+import { Relay } from "nostr-tools/relay";
+
+// Create a single EventStore instance for your app
+const eventStore = new EventStore();
+
+// Use any nostr library for relay connections (nostr-tools, ndk, nostrify, etc...)
+const relay = await Relay.connect("wss://relay.example.com");
+
+// Subscribe to events and add them to the store
+const sub = relay.subscribe([{ authors: ["3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"] }], {
+  onevent(event) {
+    eventStore.add(event);
+  },
+});
+
+// Subscribe to profile changes using ProfileModel
+const profile = eventStore.model(ProfileModel, "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d");
+
+profile.subscribe((parsed) => {
+  if (parsed) console.log(parsed);
+});
+
+// Subscribe to a timeline of events
+const timeline = eventStore.model(TimelineModel, { kinds: [1] });
+
+timeline.subscribe((events) => {
+  console.log(events);
+});
+```

package/dist/casts/cast.d.ts

@@ -0,0 +1,26 @@
+import { EventModels, IEventStoreStreams, IEventSubscriptions } from "../event-store/index.js";
+import { NostrEvent, StoreEvent } from "../helpers/event.js";
+import { EventCast } from "./event.js";
+/** The type of event store that is passed to cast references */
+export type CastRefEventStore<E extends StoreEvent = NostrEvent> = IEventSubscriptions<E> & EventModels<E> & IEventStoreStreams<E>;
+/** A symbol used to store all the cast instances for a given event */
+export declare const CAST_REF_SYMBOL: unique symbol;
+/** A symbol used to store all the casts for an event */
+export declare const CASTS_SYMBOL: unique symbol;
+/** A class that can be used to cast a Nostr event (or an unsigned {@link StoreEvent}/rumor) */
+export type CastConstructor<C extends EventCast<StoreEvent>, E extends StoreEvent = NostrEvent> = new (event: NostrEvent, store: CastRefEventStore<E>) => C;
+/**
+ * Gates {@link castEvent}'s accepted input type on whether a cast's own declared event type `T`
+ * requires a signature. If `T` carries a `sig: string` field (a `NostrEvent`-shaped cast), the
+ * input is pinned to `NostrEvent` — this rejects an unsigned rumor at compile time. Otherwise (a
+ * rumor-shaped/sig-less `T`) the input stays a loose {@link StoreEvent} — deliberately not
+ * narrowed to the cast's exact `T` (e.g. a literal `kind`), so a generic `Rumor` still satisfies
+ * a narrowed-kind rumor cast; the cast's own constructor validates the narrower shape at runtime.
+ */
+export type CastEventInput<T extends StoreEvent> = T extends {
+    sig: string;
+} ? NostrEvent : StoreEvent;
+/** @internal loose, runtime-guarded shared implementation — used by castEvent, castEventStream, and castTimelineStream */
+export declare function performCast<C extends EventCast<StoreEvent>, E extends StoreEvent = NostrEvent>(event: StoreEvent, cls: CastConstructor<C, E>, store?: CastRefEventStore<E>): C;
+/** Cast a Nostr event (or an unsigned StoreEvent/rumor) to a specific class */
+export declare function castEvent<C extends EventCast<StoreEvent>, E extends StoreEvent = NostrEvent>(event: C extends EventCast<infer T> ? CastEventInput<T> : never, cls: CastConstructor<C, E>, store?: CastRefEventStore<E>): C;

package/dist/casts/cast.js

@@ -0,0 +1,29 @@
+import { getParentEventStore } from "../helpers/event.js";
+/** A symbol used to store all the cast instances for a given event */
+export const CAST_REF_SYMBOL = Symbol.for("cast-ref");
+/** A symbol used to store all the casts for an event */
+export const CASTS_SYMBOL = Symbol.for("casts");
+/** @internal loose, runtime-guarded shared implementation — used by castEvent, castEventStream, and castTimelineStream */
+export function performCast(event, cls, store) {
+    const casts = Reflect.get(event, CASTS_SYMBOL);
+    // If the event has already been cast to this class, return the existing cast
+    const existing = casts?.get(cls);
+    if (existing)
+        return existing;
+    if (!store) {
+        store = getParentEventStore(event);
+        if (!store)
+            throw new Error("Event is not attached to an event store, an event store must be provided");
+    }
+    // Create a new instance of the class (the constructor reads only StoreEvent fields).
+    const cast = new cls(event, store);
+    if (!casts)
+        Reflect.set(event, CASTS_SYMBOL, new Map([[cls, cast]]));
+    else
+        casts.set(cls, cast);
+    return cast;
+}
+/** Cast a Nostr event (or an unsigned StoreEvent/rumor) to a specific class */
+export function castEvent(event, cls, store) {
+    return performCast(event, cls, store);
+}

package/dist/casts/event.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from "rxjs";
+import { NostrEvent, StoreEvent } from "../helpers/event.js";
+import { AddressPointer, EventPointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import { CastRefEventStore } from "./cast.js";
+import { User } from "./user.js";
+/**
+ * The base class for all casts. `T` is bounded by {@link StoreEvent} (not `NostrEvent`) so a
+ * cast can wrap an unsigned {@link Rumor} as well as a signed event — `EventCast` never reads
+ * `.sig`. The event-reading helpers below are still typed `NostrEvent`, so they are bridged
+ * with a localized `as NostrEvent`; each reads only fields present on a rumor.
+ */
+export declare class EventCast<T extends StoreEvent = NostrEvent> {
+    #private;
+    readonly event: T;
+    readonly store: CastRefEventStore;
+    /**
+     * The event viewed as a signed `NostrEvent`, for the event-reading helpers that are still
+     * typed `NostrEvent` but only touch fields a rumor already has (id/kind/pubkey/created_at/
+     * tags). A documented internal bridge until those helpers are genericized over StoreEvent.
+     */
+    private get signedView();
+    /** Alias for event.id */
+    get id(): string;
+    /** Alias for event.kind */
+    get kind(): number;
+    /** Returns the unique identifier for this event */
+    get uid(): string;
+    /** Returns the created_at timestamp as a Date object */
+    get createdAt(): Date;
+    /** Get the {@link User} that authored this event */
+    get author(): User;
+    /** Return the set of relays this event was seen on */
+    get seen(): Set<string> | undefined;
+    /** Returns the NIP-01 address string for this event if its replaceable or addressable, otherwise returns null */
+    get coordinate(): string | null;
+    /** Alias for {@link coordinate} */
+    get replaceableAddress(): string | null;
+    /** Returns a single {@link EventPointer} or {@link AddressPointer} for this event */
+    get pointer(): EventPointer | AddressPointer;
+    constructor(event: T, store: CastRefEventStore);
+    /** Internal method for creating a reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+}

package/dist/casts/event.js

@@ -0,0 +1,80 @@
+import { getEventUID, isAddressableKind, isReplaceableKind } from "../helpers/event.js";
+import { getAddressPointerForEvent, getEventPointerForEvent, getReplaceableAddressForEvent, } from "../helpers/pointers.js";
+import { getSeenRelays } from "../helpers/relays.js";
+import { chainable } from "../observable/chainable.js";
+import { castUser } from "./user.js";
+/**
+ * The base class for all casts. `T` is bounded by {@link StoreEvent} (not `NostrEvent`) so a
+ * cast can wrap an unsigned {@link Rumor} as well as a signed event — `EventCast` never reads
+ * `.sig`. The event-reading helpers below are still typed `NostrEvent`, so they are bridged
+ * with a localized `as NostrEvent`; each reads only fields present on a rumor.
+ */
+export class EventCast {
+    event;
+    store;
+    /**
+     * The event viewed as a signed `NostrEvent`, for the event-reading helpers that are still
+     * typed `NostrEvent` but only touch fields a rumor already has (id/kind/pubkey/created_at/
+     * tags). A documented internal bridge until those helpers are genericized over StoreEvent.
+     */
+    get signedView() {
+        return this.event;
+    }
+    /** Alias for event.id */
+    get id() {
+        return this.event.id;
+    }
+    /** Alias for event.kind */
+    get kind() {
+        return this.event.kind;
+    }
+    /** Returns the unique identifier for this event */
+    get uid() {
+        return getEventUID(this.signedView);
+    }
+    /** Returns the created_at timestamp as a Date object */
+    get createdAt() {
+        return new Date(this.event.created_at * 1000);
+    }
+    /** Get the {@link User} that authored this event */
+    get author() {
+        // Route via the pubkey string overload: result-identical for signed events and correct for
+        // rumors (passing the event would hit `isEvent`, which requires `sig` and misroutes a rumor).
+        return castUser(this.event.pubkey, this.store);
+    }
+    /** Return the set of relays this event was seen on */
+    get seen() {
+        return getSeenRelays(this.signedView);
+    }
+    /** Returns the NIP-01 address string for this event if its replaceable or addressable, otherwise returns null */
+    get coordinate() {
+        return getReplaceableAddressForEvent(this.signedView);
+    }
+    /** Alias for {@link coordinate} */
+    get replaceableAddress() {
+        return this.coordinate;
+    }
+    /** Returns a single {@link EventPointer} or {@link AddressPointer} for this event */
+    get pointer() {
+        if (isReplaceableKind(this.kind) || isAddressableKind(this.kind))
+            return getAddressPointerForEvent(this.signedView) || getEventPointerForEvent(this.signedView);
+        return getEventPointerForEvent(this.signedView);
+    }
+    // Enfore kind check in constructor. this will force child classes to verify the event before calling super()
+    constructor(event, store) {
+        this.event = event;
+        this.store = store;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a reference */
+    $$ref(key, builder) {
+        // Return cached observable
+        if (this.#refs[key])
+            return this.#refs[key];
+        // Build a new observable and cache it
+        const observable = chainable(builder(this.store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+}

package/dist/casts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cast.js";
+export * from "./event.js";
+export * from "./pubkey.js";
+export * from "./user.js";

package/dist/casts/index.js

@@ -0,0 +1,4 @@
+export * from "./cast.js";
+export * from "./event.js";
+export * from "./pubkey.js";
+export * from "./user.js";

package/dist/casts/pubkey.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import type { ProfilePointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import { CastRefEventStore } from "./cast.js";
+export type PubkeyCastConstructor<C extends PubkeyCast> = (new (pointer: ProfilePointer, store: CastRefEventStore) => C) & {
+    cache?: Map<string, WeakRef<C>>;
+    cacheRegistry?: FinalizationRegistry<string>;
+};
+/**
+ * Cast a pubkey to a specific class instance.
+ * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ *
+ * @note Instances are held weakly so unused casts can be garbage collected instead of
+ * accumulating one instance per pubkey for the lifetime of the process.
+ */
+export declare function castPubkey<C extends PubkeyCast>(pubkey: string | NostrEvent | ProfilePointer, cls: PubkeyCastConstructor<C>, store: CastRefEventStore): C;
+/** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
+export declare class PubkeyCast {
+    #private;
+    readonly pointer: ProfilePointer;
+    readonly store: CastRefEventStore;
+    /** A global cache of pubkey -> weak instance reference, populated by {@link castPubkey} */
+    static cache: Map<string, WeakRef<PubkeyCast>>;
+    /** Cleans up dead {@link cache} entries when their instances are garbage collected */
+    static cacheRegistry?: FinalizationRegistry<string>;
+    constructor(pointer: ProfilePointer, store: CastRefEventStore);
+    /** The hex pubkey represented by this cast */
+    get pubkey(): string;
+    /** Internal method for creating a cached observable reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+}

package/dist/casts/pubkey.js

@@ -0,0 +1,73 @@
+import { isEvent } from "../helpers/event.js";
+import { isHexKey } from "../helpers/string.js";
+import { chainable } from "../observable/chainable.js";
+const storeCacheIds = new WeakMap();
+let nextStoreCacheId = 0;
+function getStoreCacheId(store) {
+    let id = storeCacheIds.get(store);
+    if (id === undefined) {
+        id = ++nextStoreCacheId;
+        storeCacheIds.set(store, id);
+    }
+    return id;
+}
+/**
+ * Cast a pubkey to a specific class instance.
+ * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ *
+ * @note Instances are held weakly so unused casts can be garbage collected instead of
+ * accumulating one instance per pubkey for the lifetime of the process.
+ */
+export function castPubkey(pubkey, cls, store) {
+    if (isEvent(pubkey))
+        return castPubkey(pubkey.pubkey, cls, store);
+    const pointer = typeof pubkey === "string" ? { pubkey } : pubkey;
+    if (!isHexKey(pointer.pubkey))
+        throw new Error("Invalid pubkey");
+    const pointerKey = pointer.relays?.length ? `${pointer.pubkey}:${JSON.stringify(pointer.relays)}` : pointer.pubkey;
+    const cacheKey = `${getStoreCacheId(store)}:${pointerKey}`;
+    if (!cls.cache)
+        cls.cache = new Map();
+    // Clean up dead cache entries when their instances are garbage collected
+    if (!cls.cacheRegistry)
+        cls.cacheRegistry = new FinalizationRegistry((key) => {
+            // Only drop the entry if it still points at a collected instance; a re-created
+            // instance under the same key has a live ref and must be kept.
+            if (cls.cache.get(key)?.deref() === undefined)
+                cls.cache.delete(key);
+        });
+    const existing = cls.cache.get(cacheKey)?.deref();
+    if (existing)
+        return existing;
+    const instance = new cls(pointer, store);
+    cls.cache.set(cacheKey, new WeakRef(instance));
+    cls.cacheRegistry.register(instance, cacheKey);
+    return instance;
+}
+/** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
+export class PubkeyCast {
+    pointer;
+    store;
+    /** A global cache of pubkey -> weak instance reference, populated by {@link castPubkey} */
+    static cache = new Map();
+    /** Cleans up dead {@link cache} entries when their instances are garbage collected */
+    static cacheRegistry;
+    constructor(pointer, store) {
+        this.pointer = pointer;
+        this.store = store;
+    }
+    /** The hex pubkey represented by this cast */
+    get pubkey() {
+        return this.pointer.pubkey;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a cached observable reference */
+    $$ref(key, builder) {
+        if (this.#refs[key])
+            return this.#refs[key];
+        const observable = chainable(builder(this.store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+}

package/dist/casts/user.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import { Filter } from "../helpers/filter.js";
+import { ProfilePointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import type { CastConstructor, CastRefEventStore } from "./cast.js";
+import { PubkeyCast } from "./pubkey.js";
+import { EventCast } from "./event.js";
+/** Cast a Nostr event or pointer into a {@link User} */
+export declare function castUser(event: NostrEvent, store: CastRefEventStore): User;
+export declare function castUser(user: string | ProfilePointer, store: CastRefEventStore): User;
+/** A class representing a Nostr user */
+export declare class User extends PubkeyCast {
+    /** A global cache of pubkey -> weak {@link User} reference */
+    static cache: Map<string, WeakRef<User>>;
+    /** Returns the NIP-19 npub for this user */
+    get npub(): `npub1${string}`;
+    /** Returns the NIP-19 nprofile for this user */
+    get nprofile(): `nprofile1${string}`;
+    /** Subscribe to a replaceable event for this user */
+    replaceable(kind: number, identifier?: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event for this user */
+    addressable(kind: number, identifier: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    /**
+     * Creates an observable of a timeline of events created by this user
+     * @param input - The filter(s) for the timeline or kind(s)
+     * @returns A timeline observable of events by the user rom the event store
+     */
+    timeline$(input: Omit<Filter, "authors"> | Omit<Filter, "authors">[] | number | number[]): Observable<NostrEvent[]>;
+    timeline$<T extends EventCast>(input: Omit<Filter, "authors"> | Omit<Filter, "authors">[] | number | number[], cast?: CastConstructor<T>): Observable<T[]>;
+}

package/dist/casts/user.js

@@ -0,0 +1,49 @@
+import hash_sum from "hash-sum";
+import { nprofileEncode, npubEncode } from "../helpers/pointers.js";
+import { chainable } from "../observable/chainable.js";
+import { castPubkey, PubkeyCast } from "./pubkey.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
+export function castUser(user, store) {
+    return castPubkey(user, User, store);
+}
+/** A class representing a Nostr user */
+export class User extends PubkeyCast {
+    /** A global cache of pubkey -> weak {@link User} reference */
+    static cache = new Map();
+    /** Returns the NIP-19 npub for this user */
+    get npub() {
+        return npubEncode(this.pubkey);
+    }
+    /** Returns the NIP-19 nprofile for this user */
+    get nprofile() {
+        return nprofileEncode(this.pointer);
+    }
+    /** Subscribe to a replaceable event for this user */
+    replaceable(kind, identifier, relays) {
+        return chainable(this.store.replaceable({ kind, pubkey: this.pointer.pubkey, identifier, relays }));
+    }
+    /** Subscribe to an addressable event for this user */
+    addressable(kind, identifier, relays) {
+        return chainable(this.store.addressable({ kind, pubkey: this.pointer.pubkey, identifier, relays }));
+    }
+    timeline$(input, cast) {
+        let filters = [];
+        if (typeof input === "number") {
+            filters.push({ kinds: [input] });
+        }
+        else if (Array.isArray(input)) {
+            filters.push(...input.map((f) => (typeof f === "number" ? { kinds: [f] } : f)));
+        }
+        else if (input instanceof Object) {
+            filters.push(input);
+        }
+        // Use hash_sum to create a unique key for the timeline observable
+        const key = "timeline$|" + hash_sum(filters);
+        const base$ = this.$$ref(key, (store) => store.timeline(filters.map((f) => ({ ...f, authors: [this.pubkey] }))));
+        // Cast the timeline stream into a cast if provided
+        if (cast)
+            return base$.pipe(castTimelineStream(cast));
+        else
+            return base$;
+    }
+}

package/dist/event-store/async-delete-manager.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from "rxjs";
+import { NostrEvent, StoreEvent } from "../helpers/event.js";
+import { DeleteEventNotification, IAsyncDeleteManager } from "./interface.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export declare class AsyncDeleteManager<E extends StoreEvent = NostrEvent> implements IAsyncDeleteManager<E> {
+    /** A stream of pointers that may have been deleted */
+    readonly deleted$: Observable<DeleteEventNotification>;
+    /** Internal sync delete manager instance for state */
+    private internal;
+    constructor();
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    add(deleteEvent: E): Promise<DeleteEventNotification[]>;
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    check(event: E): Promise<boolean>;
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    filter(events: E[]): Promise<E[]>;
+}

package/dist/event-store/async-delete-manager.js

@@ -0,0 +1,33 @@
+import { DeleteManager } from "./delete-manager.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export class AsyncDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    deleted$;
+    /** Internal sync delete manager instance for state */
+    internal;
+    constructor() {
+        this.internal = new DeleteManager();
+        this.deleted$ = this.internal.deleted$;
+    }
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    async add(deleteEvent) {
+        return this.internal.add(deleteEvent);
+    }
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    async check(event) {
+        return this.internal.check(event);
+    }
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    async filter(events) {
+        return this.internal.filter(events);
+    }
+}

package/dist/event-store/async-event-store.d.ts

@@ -0,0 +1,111 @@
+import { Observable, Subject } from "rxjs";
+import { NostrEvent, StoreEvent } from "../helpers/event.js";
+import { Filter } from "../helpers/filter.js";
+import { AddressPointer, AddressPointerWithoutD, EventPointer } from "../helpers/pointers.js";
+import { EventMemory } from "./event-memory.js";
+import { EventModels } from "./event-models.js";
+import { IAsyncDeleteManager, IAsyncEventDatabase, IAsyncEventStore, IExpirationManager } from "./interface.js";
+export type AsyncEventStoreOptions<E extends StoreEvent = NostrEvent> = {
+    /** Keep deleted events in the store */
+    keepDeleted?: boolean;
+    /** Keep expired events in the store */
+    keepExpired?: boolean;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions?: boolean;
+    /** The database to use for storing events */
+    database: IAsyncEventDatabase<E>;
+    /** Custom {@link IAsyncDeleteManager} implementation */
+    deleteManager?: IAsyncDeleteManager<E>;
+    /** Custom {@link IExpirationManager} implementation */
+    expirationManager?: IExpirationManager<E>;
+    /** The method used to verify events */
+    verifyEvent?: (event: E) => boolean;
+};
+/** An async wrapper around an async event database that handles replaceable events, deletes, and models */
+export declare class AsyncEventStore<E extends StoreEvent = NostrEvent> extends EventModels<E> implements IAsyncEventStore<E> {
+    database: IAsyncEventDatabase<E>;
+    /** Optional memory database for ensuring single event instances */
+    memory: EventMemory<E>;
+    /** Manager for handling event deletions with authorization */
+    private deletes;
+    /** Manager for handling event expirations */
+    private expiration;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions: boolean;
+    /** Keep expired events in the store */
+    keepExpired: boolean;
+    /** Keep deleted events in the store */
+    keepDeleted: boolean;
+    /** The method used to verify events */
+    private _verifyEventMethod?;
+    /** Get the method used to verify events */
+    get verifyEvent(): undefined | ((event: E) => boolean);
+    /** Sets the method used to verify events */
+    set verifyEvent(method: undefined | ((event: E) => boolean));
+    /** A stream of new events added to the store */
+    insert$: Subject<E>;
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
+    update$: Subject<E>;
+    /** A stream of events that have been removed */
+    remove$: Subject<E>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     */
+    eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<E> | Promise<E | undefined>;
+    /** Internal subscriptions (delete + expiration managers) torn down on dispose */
+    private internalSubscriptions;
+    constructor(options: AsyncEventStoreOptions<E>);
+    /** A method to add all events to memory to ensure there is only ever a single instance of an event */
+    private mapToMemory;
+    /** Handle a delete event by pointer */
+    private handleDeleteNotification;
+    /** Handle an expired event by id */
+    private handleExpiredNotification;
+    /**
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
+     */
+    add(event: E, fromRelay?: string): Promise<E | null>;
+    /** Removes an event from the store and updates subscriptions */
+    remove(event: string | E): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): Promise<number>;
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event: E): Promise<void>;
+    /** Check if the store has an event by id */
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<boolean>;
+    /** Get an event by id from the store */
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<E | undefined>;
+    /** Check if the store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, d?: string): Promise<boolean>;
+    /** Gets the latest version of a replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<E | undefined>;
+    /** Returns all versions of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<E[] | undefined>;
+    /** Get all events matching a filter */
+    getByFilters(filters: Filter | Filter[]): Promise<E[]>;
+    /** Returns a timeline of events that match filters */
+    getTimeline(filters: Filter | Filter[]): Promise<E[]>;
+    /** Passthrough method for the database.touch */
+    touch(event: E): void;
+    /** Increments the claim count on the event and touches it */
+    claim(event: E): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: E): boolean;
+    /** Decrements the claim count on an event */
+    removeClaim(event: E): void;
+    /** Removes all claims on an event */
+    clearClaim(event: E): void;
+    /** Pass through method for the database.unclaimed */
+    unclaimed(): Generator<E>;
+    /** Removes any event that is not being used by a subscription */
+    prune(limit?: number): number;
+    /**
+     * Tears down the store: disposes the attached event loader, completes the event streams, releases
+     * model keep-warm timers, unsubscribes internal manager listeners, and cancels any pending expiration timer.
+     * @note This is a terminal operation; the store should be discarded after calling it.
+     */
+    dispose(): void;
+    /** Allows the store to be used with the `using` keyword */
+    [Symbol.dispose](): void;
+}