applesauce-core 2.3.0 → 3.0.1

package/dist/helpers/calendar-rsvp.js

@@ -0,0 +1,38 @@
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { isATag, isETag, isPTag } from "./tags.js";
+export const CALENDAR_EVENT_RSVP_KIND = 31925;
+/** Gets the RSVP status from a calendar event RSVP */
+export function getRSVPStatus(event) {
+    const status = getTagValue(event, "status");
+    return status && ["accepted", "declined", "tentative"].includes(status) ? status : undefined;
+}
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export function getRSVPFreeBusy(event) {
+    const status = getRSVPStatus(event);
+    if (status === "declined")
+        return undefined;
+    const fb = getTagValue(event, "fb");
+    return fb && ["free", "busy"].includes(fb) ? fb : undefined;
+}
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export function getRSVPAddressPointer(event) {
+    const tag = event.tags.find(isATag);
+    if (!tag)
+        return undefined;
+    return getAddressPointerFromATag(tag);
+}
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export function getRSVPEventPointer(event) {
+    const tag = event.tags.find(isETag);
+    if (!tag)
+        return undefined;
+    return getEventPointerFromETag(tag);
+}
+/** Gets the profile pointer that the RSVP is responding to */
+export function getRSVPProfilePointer(event) {
+    const tag = event.tags.find(isPTag);
+    if (!tag)
+        return undefined;
+    return getProfilePointerFromPTag(tag);
+}

package/dist/helpers/calendar.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer } from "nostr-tools/nip19";
+/** Gets the title of a calendar */
+export declare function getCalendarTitle(event: NostrEvent): string | undefined;
+/** Gets the address pointers to all the events on the calendar */
+export declare function getCalendarAddressPointers(event: NostrEvent): AddressPointer[];

package/dist/helpers/calendar.js

@@ -0,0 +1,11 @@
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { isATag } from "./tags.js";
+/** Gets the title of a calendar */
+export function getCalendarTitle(event) {
+    return getTagValue(event, "title");
+}
+/** Gets the address pointers to all the events on the calendar */
+export function getCalendarAddressPointers(event) {
+    return event.tags.filter(isATag).map(getAddressPointerFromATag);
+}

package/dist/helpers/encrypted-content.d.ts

@@ -10,18 +10,26 @@ export interface EncryptedContentSigner {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 }
-/** Various event kinds that can have encrypted content and which encryption method they use */
-export declare const EventContentEncryptionMethod: Record<number, "nip04" | "nip44">;
-/** Sets the encryption method that is used for the contents of a specific event kind */
-export declare function setEncryptedContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner): {
+export type EncryptionMethod = "nip04" | "nip44";
+/** A pair of encryption methods for encrypting and decrypting event content */
+export interface EncryptionMethods {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
     decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
+}
+/** Various event kinds that can have encrypted content and which encryption method they use */
+export declare const EventContentEncryptionMethod: Record<number, EncryptionMethod>;
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export declare function setEncryptedContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner, override?: EncryptionMethod): EncryptionMethods;
 /** Checks if an event can have encrypted content */
 export declare function canHaveEncryptedContent(kind: number): boolean;
 /** Checks if an event has encrypted content */

package/dist/helpers/encrypted-content.js

@@ -13,9 +13,17 @@ export function setEncryptedContentEncryptionMethod(kind, method) {
     EventContentEncryptionMethod[kind] = method;
     return kind;
 }
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export function getEncryptedContentEncryptionMethods(kind, signer) {
-    const method = EventContentEncryptionMethod[kind];
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export function getEncryptedContentEncryptionMethods(kind, signer, override) {
+    const method = override ?? EventContentEncryptionMethod[kind];
     if (!method)
         throw new Error(`Event kind ${kind} does not support encrypted content`);
     const encryption = signer[method];

package/dist/helpers/event-cache.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export declare function presistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
+    maxBatchSize?: number;
+    batchTime?: number;
+}): () => void;

package/dist/helpers/event-cache.js

@@ -0,0 +1,32 @@
+import { bufferTime, filter } from "rxjs";
+import { logger } from "../logger.js";
+import { isFromCache } from "./index.js";
+const log = logger.extend("event-cache");
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export function presistEventsToCache(eventStore, write, opts) {
+    const time = opts?.batchTime ?? 5_000;
+    // Save all new events to the cache
+    const sub = eventStore.insert$
+        .pipe(
+    // Only select events that are not from the cache
+    filter((e) => !isFromCache(e)), 
+    // Buffer events for 5 seconds
+    opts?.maxBatchSize ? bufferTime(time, undefined, opts?.maxBatchSize ?? 100) : bufferTime(time), 
+    // Only select buffers with events
+    filter((b) => b.length > 0))
+        .subscribe((events) => {
+        // Save all new events to the cache
+        write(events)
+            .then(() => log(`Saved ${events.length} events to cache`))
+            .catch((e) => log(`Failed to save ${events.length} events to cache`, e));
+    });
+    return () => sub.unsubscribe();
+}

package/dist/helpers/event.d.ts

@@ -39,10 +39,7 @@ export declare function isFromCache(event: NostrEvent): boolean;
 export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
 /** Notifies the events parent store that an event has been updated */
 export declare function notifyEventUpdate(event: NostrEvent): void;
-/**
- * Returns the replaceable identifier for a replaceable event
- * @throws
- */
+/** Returns the replaceable identifier for a replaceable event */
 export declare function getReplaceableIdentifier(event: NostrEvent): string;
 /** Checks if an event is a NIP-70 protected event */
 export declare function isProtectedEvent(event: NostrEvent): boolean;

package/dist/helpers/event.js

@@ -85,18 +85,10 @@ export function notifyEventUpdate(event) {
     if (eventStore)
         eventStore.update(event);
 }
-/**
- * Returns the replaceable identifier for a replaceable event
- * @throws
- */
+/** Returns the replaceable identifier for a replaceable event */
 export function getReplaceableIdentifier(event) {
-    if (!isAddressableKind(event.kind))
-        throw new Error("Event is not addressable");
     return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
-        const d = event.tags.find((t) => t[0] === "d")?.[1];
-        if (d === undefined)
-            throw new Error("Event missing identifier");
-        return d;
+        return event.tags.find((t) => t[0] === "d")?.[1] ?? "";
     });
 }
 /** Checks if an event is a NIP-70 protected event */

package/dist/helpers/expiration.js

@@ -1,11 +1,10 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { unixNow } from "./time.js";
-import { getTagValue } from "./event-tags.js";
 export const ExpirationTimestampSymbol = Symbol("expiration-timestamp");
 /** Returns the NIP-40 expiration timestamp for an event */
 export function getExpirationTimestamp(event) {
     return getOrComputeCachedValue(event, ExpirationTimestampSymbol, () => {
-        const expiration = getTagValue(event, "expiration");
+        const expiration = event.tags.find((t) => t[0] === "expiration")?.[1];
         return expiration ? parseInt(expiration) : undefined;
     });
 }

package/dist/helpers/hidden-content.d.ts

@@ -1,4 +1,4 @@
-import { EncryptedContentSigner, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
+import { EncryptedContentSigner, EncryptionMethod, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
 export declare const HiddenContentSymbol: symbol;
 export interface HiddenContentSigner extends EncryptedContentSigner {
 }
@@ -6,7 +6,7 @@ export declare const getHiddenContentEncryptionMethods: typeof getEncryptedConte
 /** Various event kinds that can have hidden content */
 export declare const HiddenContentKinds: Set<number>;
 /** Sets the encryption method for hidden content on a kind */
-export declare function setHiddenContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event can have hidden content */
 export declare function canHaveHiddenContent(kind: number): boolean;
 /** Checks if an event has hidden content */
@@ -31,7 +31,7 @@ export declare function unlockHiddenContent<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: EncryptedContentSigner): Promise<string>;
+}>(event: T, signer: EncryptedContentSigner, override?: EncryptionMethod): Promise<string>;
 /**
  * Sets the hidden content on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-content.js

@@ -34,10 +34,10 @@ export function getHiddenContent(event) {
  * @param signer A signer to use to decrypt the content
  * @throws
  */
-export async function unlockHiddenContent(event, signer) {
+export async function unlockHiddenContent(event, signer, override) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
-    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
+    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer, override);
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
     setHiddenContentCache(event, plaintext);
     return plaintext;

package/dist/helpers/hidden-tags.d.ts

@@ -1,11 +1,12 @@
 import { HiddenContentSigner } from "./hidden-content.js";
+import { EncryptionMethod } from "./encrypted-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
 /** Various event kinds that can have hidden tags */
 export declare const HiddenTagsKinds: Set<number>;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Sets the type of encryption to use for hidden tags on a kind */
-export declare function setHiddenTagsEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenTagsEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event has hidden tags */
 export declare function hasHiddenTags<T extends {
     kind: number;
@@ -19,25 +20,19 @@ export declare function getHiddenTags<T extends {
 /** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): import("./encrypted-content.js").EncryptionMethods;
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
 export declare function unlockHiddenTags<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+}>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<string[][]>;
 /**
  * Sets the hidden tags on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-tags.js

@@ -58,15 +58,15 @@ export function getHiddenTagsEncryptionMethods(kind, signer) {
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
-export async function unlockHiddenTags(event, signer) {
+export async function unlockHiddenTags(event, signer, override) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
     // unlock hidden content is needed
     if (isHiddenContentLocked(event))
-        await unlockHiddenContent(event, signer);
+        await unlockHiddenContent(event, signer, override);
     return getHiddenTags(event);
 }
 /**

package/dist/helpers/highlight.d.ts

@@ -0,0 +1,45 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const HighlightSourceEventPointerSymbol: unique symbol;
+export declare const HighlightSourceAddressPointerSymbol: unique symbol;
+export declare const HighlightAttributionSymbol: unique symbol;
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export declare function getHighlightText(event: NostrEvent): string;
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export declare function getHighlightSourceEventPointer(event: NostrEvent): EventPointer | undefined;
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export declare function getHighlightSourceAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Get the source URL that was highlighted (from 'r' tag) */
+export declare function getHighlightSourceUrl(event: NostrEvent): string | undefined;
+/** Role of an attributed profiles in a highlight */
+export type HighlightAttributionRole = "author" | "editor" | "mention" | string;
+/** Attribution information for a highlight */
+export type HighlightAttribution = ProfilePointer & {
+    /** Role of the attributed profile */
+    role?: HighlightAttributionRole;
+};
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export declare function getHighlightAttributions(event: NostrEvent): HighlightAttribution[];
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export declare function getHighlightContext(event: NostrEvent): string | undefined;
+/** Get the comment for a highlight (from 'comment' tag) */
+export declare function getHighlightComment(event: NostrEvent): string | undefined;
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export declare function hasHighlightSource(event: NostrEvent): boolean;

package/dist/helpers/highlight.js

@@ -0,0 +1,76 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { isATag, isETag, isPTag } from "./tags.js";
+// Symbol constants for caching
+export const HighlightSourceEventPointerSymbol = Symbol.for("highlight-source-event-pointer");
+export const HighlightSourceAddressPointerSymbol = Symbol.for("highlight-source-address-pointer");
+export const HighlightAttributionSymbol = Symbol.for("highlight-attribution");
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export function getHighlightText(event) {
+    return event.content;
+}
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export function getHighlightSourceEventPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceEventPointerSymbol, () => {
+        const eTag = event.tags.find(isETag);
+        return eTag ? getEventPointerFromETag(eTag) : undefined;
+    });
+}
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export function getHighlightSourceAddressPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceAddressPointerSymbol, () => {
+        const aTag = event.tags.find(isATag);
+        return aTag ? getAddressPointerFromATag(aTag) : undefined;
+    });
+}
+/** Get the source URL that was highlighted (from 'r' tag) */
+export function getHighlightSourceUrl(event) {
+    return getTagValue(event, "r");
+}
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export function getHighlightAttributions(event) {
+    return getOrComputeCachedValue(event, HighlightAttributionSymbol, () => {
+        const attributions = [];
+        const pTags = event.tags.filter(isPTag);
+        for (const pTag of pTags) {
+            const pointer = getProfilePointerFromPTag(pTag);
+            const role = pTag[3] || "other"; // Role is the 4th element (index 3)
+            const entry = { ...pointer, role };
+            // Categorize by role
+            attributions.push(entry);
+        }
+        return attributions;
+    });
+}
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export function getHighlightContext(event) {
+    return getTagValue(event, "context");
+}
+/** Get the comment for a highlight (from 'comment' tag) */
+export function getHighlightComment(event) {
+    return getTagValue(event, "comment");
+}
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export function hasHighlightSource(event) {
+    return !!(getHighlightSourceEventPointer(event) ||
+        getHighlightSourceAddressPointer(event) ||
+        getHighlightSourceUrl(event));
+}

package/dist/helpers/index.d.ts

@@ -4,6 +4,9 @@ export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comment.js";
 export * from "./contacts.js";
@@ -14,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
@@ -25,6 +29,7 @@ export * from "./groups.js";
 export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./highlight.js";
 export * from "./json.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
@@ -35,11 +40,14 @@ export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";

package/dist/helpers/index.js

@@ -4,6 +4,9 @@ export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comment.js";
 export * from "./contacts.js";
@@ -14,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
@@ -25,6 +29,7 @@ export * from "./groups.js";
 export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./highlight.js";
 export * from "./json.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
@@ -35,11 +40,14 @@ export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";

package/dist/helpers/pointers.js

@@ -187,7 +187,7 @@ export function addRelayHintsToPointer(pointer, relays) {
 /** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
     if (isHexKey(str))
-        return str;
+        return str.toLowerCase();
     else {
         const decode = nip19.decode(str);
         const pubkey = getPubkeyFromDecodeResult(decode);

package/dist/helpers/poll.d.ts

@@ -0,0 +1,46 @@
+import { NostrEvent } from "nostr-tools";
+export declare const POLL_KIND = 1068;
+export declare const POLL_RESPONSE_KIND = 1018;
+export declare const PollOptionsSymbol: unique symbol;
+export interface PollOption {
+    id: string;
+    label: string;
+}
+export type PollType = "singlechoice" | "multiplechoice";
+/**
+ * Get the poll question/label from a poll event
+ * Returns the content field which contains the poll question
+ */
+export declare function getPollQuestion(event: NostrEvent): string;
+/**
+ * Get the poll options from a poll event
+ * Returns array of options with id and label
+ */
+export declare function getPollOptions(event: NostrEvent): PollOption[];
+/**
+ * Get the relays specified for poll responses (from 'relay' tags)
+ * Returns undefined if no relays are specified
+ */
+export declare function getPollRelays(event: NostrEvent): string[];
+/**
+ * Get the poll type from a poll event (from 'polltype' tag)
+ * Returns "singlechoice" or "multiplechoice", defaults to "singlechoice"
+ */
+export declare function getPollType(event: NostrEvent): PollType;
+/**
+ * Get the poll expiration timestamp (from 'endsAt' tag)
+ * Returns undefined if no expiration is set
+ */
+export declare function getPollEndsAt(event: NostrEvent): number | undefined;
+/**
+ * Get the poll ID that a response is referencing (from 'e' tag)
+ * Returns undefined if no poll reference is found
+ */
+export declare function getPollResponsePollId(event: NostrEvent): string | undefined;
+/** Get the selected option IDs from a poll response event (from 'response' tags) */
+export declare function getPollResponseOptions(event: NostrEvent): string[];
+/**
+ * Gets the options that a user has voted for in a poll event
+ * Returns undefined if the response is not valid
+ */
+export declare function getPollResponseVotes(poll: NostrEvent, response: NostrEvent): string[] | undefined;