Applesauce
    Preparing search index...

    Interface IAsyncEventStore<E>

    Generic async event store interface

    interface IAsyncEventStore<E extends StoreEvent = NostrEvent> {
        eventLoader?: (
            pointer: AddressPointer | EventPointer | AddressPointerWithoutD,
        ) => Promise<E | undefined> | Observable<E>;
        getSyncPairs?: (filters: Filter | Filter[]) => Promise<SyncPair[]>;
        insert$: Observable<E>;
        remove$: Observable<E>;
        update$: Observable<E>;
        add(event: E): Promise<E | null>;
        addressable(pointer: AddressPointer): Observable<E | undefined>;
        claim(event: E): void;
        clearClaim(event: E): void;
        contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
        event(
            id: string | AddressPointer | EventPointer | AddressPointerWithoutD,
        ): Observable<E | undefined>;
        filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<E>;
        getByFilters(filters: Filter | Filter[]): Promise<E[]>;
        getEvent(
            id: string | AddressPointer | EventPointer | AddressPointerWithoutD,
        ): Promise<E | undefined>;
        getReplaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<E | undefined>;
        getReplaceableHistory(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<E[] | undefined>;
        getTimeline(filters: Filter | Filter[]): Promise<E[]>;
        hasEvent(
            id: string | AddressPointer | EventPointer | AddressPointerWithoutD,
        ): Promise<boolean>;
        hasReplaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<boolean>;
        isClaimed(event: E): boolean;
        mailboxes(
            user: string | ProfilePointer,
        ): Observable<{ inboxes: string[]; outboxes: string[] } | undefined>;
        model<T extends unknown, Args extends any[]>(
            constructor: ModelConstructor<T, Args, E, IAsyncEventStore<E>>,
            ...args: Args,
        ): Observable<T>;
        profile(
            user: string | ProfilePointer,
        ): Observable<ProfileContent | undefined>;
        remove(event: string | E): Promise<boolean>;
        removeClaim(event: E): void;
        replaceable(pointer: AddressPointerWithoutD): Observable<E | undefined>;
        replaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Observable<E | undefined>;
        timeline(filters: Filter | Filter[], onlyNew?: boolean): Observable<E[]>;
        touch(event: E): void;
        unclaimed(): Generator<E>;
        update(event: E): Promise<void>;
    }

    Type Parameters

    Hierarchy (View Summary)

    Implemented by

    Index
    eventLoader? getSyncPairs? insert$ remove$ update$
    add addressable claim clearClaim contacts event filters getByFilters getEvent getReplaceable getReplaceableHistory getTimeline hasEvent hasReplaceable isClaimed mailboxes model profile remove removeClaim replaceable timeline touch unclaimed update
    eventLoader?: (
        pointer: AddressPointer | EventPointer | AddressPointerWithoutD,
    ) => Promise<E | undefined> | Observable<E>

    A method that will be called when an event isn't found in the store

    getSyncPairs?: (filters: Filter | Filter[]) => Promise<SyncPair[]>

    Type Declaration

    insert$: Observable<E>

    A stream of new events added to the store

    remove$: Observable<E>

    A stream of events that have been removed

    update$: Observable<E>

    A stream of events that have been updated

    Settings
    Member Visibility

    On This Page
    Properties
    Methods