@qntx/nostr 0.0.1

package/dist/index-BYMnhRIC.d.mts

@@ -0,0 +1,161 @@
+import { n as EventTemplate, r as UnsignedEvent, t as Event } from "./event-B5D2jxt_.mjs";
+import { r as SecretKey, t as Keys } from "./key-BiGxGLhg.mjs";
+import { t as Filter } from "./filter-DUEKP3q1.mjs";
+import { t as NostrSigner } from "./types-BzyADqnw.mjs";
+import { n as BunkerPointer, r as ClientMetadata } from "./nip46-C_DoxiS_.mjs";
+//#region src/signer/keys.d.ts
+/** Local secret-key signer with NIP-04 (legacy) and NIP-44 support. */
+declare class KeysSigner implements NostrSigner {
+  #private;
+  constructor(secretKey: SecretKey | Uint8Array | string | Keys);
+  get keys(): Keys;
+  getPublicKey(): Promise<string>;
+  signEvent(unsigned: UnsignedEvent): Promise<Event>;
+  nip04Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip04Decrypt(peer: string, ciphertext: string): Promise<string>;
+  nip44Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip44Decrypt(peer: string, payload: string): Promise<string>;
+}
+//#endregion
+//#region src/signer/nip07.d.ts
+/**
+ * Minimal NIP-07 provider surface (browser extension `window.nostr`).
+ * @see https://github.com/nostr-protocol/nips/blob/master/07.md
+ */
+type WindowNostr = {
+  getPublicKey(): Promise<string>;
+  signEvent(event: EventTemplate): Promise<Event>;
+  nip04?: {
+    encrypt(pubkey: string, plaintext: string): Promise<string>;
+    decrypt(pubkey: string, ciphertext: string): Promise<string>;
+  };
+  nip44?: {
+    encrypt(pubkey: string, plaintext: string): Promise<string>;
+    decrypt(pubkey: string, ciphertext: string): Promise<string>;
+  };
+};
+/** Resolve `window.nostr` / `globalThis.nostr` when present. */
+declare function getWindowNostr(): WindowNostr | undefined;
+/** True when a NIP-07 provider is injected in the current environment. */
+declare function isNip07Available(): boolean;
+/**
+ * Signer backed by a NIP-07 browser extension (or any injected provider).
+ * Never holds secret keys in-process.
+ */
+declare class Nip07Signer implements NostrSigner {
+  #private;
+  constructor(provider?: WindowNostr);
+  getPublicKey(): Promise<string>;
+  signEvent(unsigned: UnsignedEvent): Promise<Event>;
+  nip04Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip04Decrypt(peer: string, ciphertext: string): Promise<string>;
+  nip44Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip44Decrypt(peer: string, payload: string): Promise<string>;
+}
+//#endregion
+//#region src/signer/nip46.d.ts
+/** Subscribe options used by NIP-46 transport (structural subset of Pool). */
+type Nip46SubscribeOptions = {
+  signal?: AbortSignal;
+  onevent?: (event: Event) => void;
+  onclose?: (reason: string) => void;
+};
+/**
+ * Structural relay transport for NIP-46 RPC.
+ * Satisfied by {@link import("../relay/pool.ts").Pool}; constructed above the signer layer
+ * so `signer` never imports `relay` (ADR-0001).
+ */
+type Nip46Transport = {
+  subscribe(relays: string[], filters: Filter[], opts?: Nip46SubscribeOptions): {
+    close: (reason?: string) => void;
+  };
+  publish(relays: string[], event: Event): Promise<unknown>;
+  close(urls?: string[]): void;
+};
+type Nip46SignerOptions = {
+  /**
+   * Shared transport. When set, the signer does not close it on {@link Nip46Signer.close}.
+   */
+  pool?: Nip46Transport;
+  /**
+   * Factory for a private transport when `pool` is omitted.
+   * Typical: `() => new Pool({ websocketImplementation, enableReconnect: true })`.
+   */
+  createPool?: () => Nip46Transport;
+  /**
+   * Relays used when the bunker pointer has none, and merged uniquely onto a
+   * nonempty pointer (pointer first).
+   */
+  relays?: string[];
+  /**
+   * Bunker connection secret when the pointer or bunker:// URL has none.
+   */
+  secret?: string | null;
+  /** Local client key used to encrypt RPC (not the remote user key). */
+  clientSecretKey?: SecretKey | Uint8Array | string;
+  /** Called when bunker returns `auth_url` for a pending request. */
+  onAuthUrl?: (url: string) => void;
+  /** Per-request timeout in ms. Default 30s. */
+  timeoutMs?: number;
+  /** Requested permissions sent with `connect` (`method[:kind]` list). */
+  perms?: string[];
+  /** Client metadata sent with bunker-initiated `connect`. */
+  metadata?: ClientMetadata;
+};
+/**
+ * NIP-46 remote signer (bunker / nostrconnect).
+ * Implements {@link NostrSigner}; never holds the remote user's secret key.
+ * Network I/O is injected via {@link Nip46Transport} (no relay import).
+ */
+declare class Nip46Signer implements NostrSigner {
+  #private;
+  private constructor();
+  get bunker(): Readonly<BunkerPointer>;
+  get clientPublicKey(): string;
+  /**
+   * Subscribe to an already-known bunker pointer. Does not send the `connect` RPC
+   * (reconnect without a new handshake).
+   * Requires `clientSecretKey` — reconnect must reuse the original client identity.
+   */
+  static fromBunker(pointer: BunkerPointer, opts: Nip46SignerOptions & {
+    clientSecretKey: SecretKey | Uint8Array | string;
+  }): Nip46Signer;
+  /**
+   * Connect using a `bunker://` URL or pre-parsed pointer.
+   * Invalid strings throw. A NIP-05 identifier is not a bunker pointer.
+   * When both pointer and `opts.relays` are nonempty, unique `opts.relays` are appended.
+   */
+  static connect(input: string | BunkerPointer, opts?: Nip46SignerOptions): Promise<Nip46Signer>;
+  /**
+   * Wait for a bunker to complete a client-initiated `nostrconnect://` handshake.
+   * Requires `clientSecretKey` whose pubkey matches the URI client pubkey
+   * (build the URI with {@link createNostrConnectURI} after generating keys).
+   */
+  static fromNostrConnectURI(connectionURI: string, opts: Nip46SignerOptions & {
+    clientSecretKey: SecretKey | Uint8Array | string;
+    signal?: AbortSignal;
+    handshakeTimeoutMs?: number;
+  }): Promise<Nip46Signer>;
+  connectRemote(overrides?: {
+    metadata?: ClientMetadata;
+    perms?: string[];
+  }): Promise<void>;
+  /**
+   * Ask the bunker for its preferred relay list and resubscribe when it changes.
+   * Spec result is a JSON array of URLs, or `null` when nothing changes.
+   */
+  switchRelays(): Promise<string[] | null>;
+  /** Courtesy session teardown. Always closes the local signer afterwards. */
+  logout(): Promise<void>;
+  ping(): Promise<void>;
+  getPublicKey(): Promise<string>;
+  signEvent(unsigned: UnsignedEvent): Promise<Event>;
+  nip04Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip04Decrypt(peer: string, ciphertext: string): Promise<string>;
+  nip44Encrypt(peer: string, plaintext: string): Promise<string>;
+  nip44Decrypt(peer: string, payload: string): Promise<string>;
+  close(): Promise<void>;
+}
+//#endregion
+export { Nip07Signer as a, isNip07Available as c, Nip46Transport as i, KeysSigner as l, Nip46SignerOptions as n, WindowNostr as o, Nip46SubscribeOptions as r, getWindowNostr as s, Nip46Signer as t };
+//# sourceMappingURL=index-BYMnhRIC.d.mts.map

package/dist/index-C0C4e-Gn.d.mts

@@ -0,0 +1,55 @@
+import { t as Event } from "./event-B5D2jxt_.mjs";
+import { t as Filter } from "./filter-DUEKP3q1.mjs";
+import { a as NostrError } from "./error-WEFS-R-4.mjs";
+import { t as Pool } from "./pool-DhRi7l-b.mjs";
+//#region src/relay/error.d.ts
+declare class RelayError extends NostrError {
+  readonly url?: string;
+  constructor(message: string, url?: string);
+}
+declare class RelayConnectionError extends RelayError {}
+declare class RelayPublishError extends RelayError {}
+declare class RelayClosedError extends RelayError {}
+//#endregion
+//#region src/relay/url.d.ts
+/**
+ * True for `ws:` / `http:` URLs that are not `.onion`.
+ * Local-network `ws://` is still insecure; allow those via a trusted set.
+ */
+declare function isInsecureRelayUrl(url: string): boolean;
+//#endregion
+//#region src/relay/fan-in.d.ts
+type RoutedJob = {
+  urls: readonly string[];
+  filters: readonly Filter[];
+  id?: string;
+};
+type FanInOptions = {
+  onevent?: (event: Event) => void;
+  oneose?: () => void;
+  onclose?: (reason: string) => void;
+  signal?: AbortSignal;
+  /** Armed at fan-in only. Never forwarded to relay.subscribe. */
+  eoseTimeoutMs?: number;
+  alreadyHaveEvent?: (id: string) => boolean;
+  receivedEvent?: (id: string) => void;
+  closeOnEose?: boolean;
+  /** Optional. ensureRelay uses Pool.#opts.connectTimeoutMs when omitted. */
+  connectTimeoutMs?: number;
+};
+/**
+ * Aggregate EOSE/close across routed jobs. One `seen` set.
+ * `pending` counts URL list entries (duplicates included).
+ * `pendingEose` counts unique `jobIndex:url` keys.
+ */
+declare function fanIn(pool: Pool, jobs: readonly RoutedJob[], opts?: FanInOptions): {
+  close: (reason?: string) => void;
+};
+declare function fetchRouted(pool: Pool, jobs: readonly RoutedJob[], opts?: {
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  connectTimeoutMs?: number;
+}): Promise<Event[]>;
+//#endregion
+export { isInsecureRelayUrl as a, RelayError as c, fetchRouted as i, RelayPublishError as l, RoutedJob as n, RelayClosedError as o, fanIn as r, RelayConnectionError as s, FanInOptions as t };
+//# sourceMappingURL=index-C0C4e-Gn.d.mts.map

package/dist/index-CaxrMD1A.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/index-DaRyjo7O.d.mts

@@ -0,0 +1,77 @@
+//#region src/core/limits.d.ts
+/** NIP-01 event id length in bytes. */
+declare const EVENT_ID_BYTES = 32;
+/** BIP-340 signature length in bytes. */
+declare const SIGNATURE_BYTES = 64;
+/** BIP-340 public key length in bytes (x-only). */
+declare const PUBLIC_KEY_BYTES = 32;
+/** BIP-340 secret key length in bytes. */
+declare const SECRET_KEY_BYTES = 32;
+/** NIP-01 subscription id max character length. */
+declare const SUBSCRIPTION_ID_MAX_CHARS = 64;
+//#endregion
+//#region src/core/util.d.ts
+declare const utf8Encoder: import("node:util").TextEncoder;
+declare const utf8Decoder: import("node:util").TextDecoder;
+/** Lowercase hex encode. */
+declare function bytesToHex(bytes: Uint8Array): string;
+/** Decode lowercase or mixed-case hex to bytes. */
+declare function hexToBytes(hex: string): Uint8Array;
+/** True when value is a 64-char hex string (any case) — 32 bytes. */
+declare function isHex32(value: string): boolean;
+/** True when value is a 128-char hex string (any case) — 64 bytes. */
+declare function isHex64(value: string): boolean;
+declare function assertHex32(value: string, label: string): string;
+declare function assertSecretKeyBytes(bytes: Uint8Array): void;
+/**
+ * Normalize a relay URL to a stable form (wss preferred, no trailing slash, sorted query).
+ */
+declare function normalizeURL(url: string): string;
+//#endregion
+//#region src/core/kind.d.ts
+/** NIP-01 regular: stored by relays. */
+declare function isRegularKind(kind: number): boolean;
+/** Replaceable: latest per (pubkey, kind) wins. */
+declare function isReplaceableKind(kind: number): boolean;
+/** Ephemeral: not expected to be stored. */
+declare function isEphemeralKind(kind: number): boolean;
+/** Addressable (parameterized replaceable): latest per (pubkey, kind, d-tag) wins. */
+declare function isAddressableKind(kind: number): boolean;
+type KindClassification = "regular" | "replaceable" | "ephemeral" | "addressable" | "unknown";
+declare function classifyKind(kind: number): KindClassification;
+/** Kind numbers used by this package. */
+declare const Kind: {
+  readonly Metadata: 0;
+  readonly TextNote: 1;
+  readonly Contacts: 3;
+  readonly EventDeletion: 5;
+  readonly Repost: 6;
+  readonly Reaction: 7;
+  readonly Seal: 13;
+  readonly PrivateDirectMessage: 14;
+  readonly GenericRepost: 16;
+  readonly GiftWrap: 1059;
+  readonly ZapRequest: 9734;
+  readonly Zap: 9735;
+  readonly MuteList: 10000;
+  readonly PinList: 10001;
+  readonly RelayList: 10002;
+  readonly BookmarkList: 10003;
+  readonly FavoriteRelays: 10012;
+  readonly UserEmojiList: 10030;
+  readonly DirectMessageRelaysList: 10050;
+  readonly BlossomServerList: 10063;
+  readonly GiftWrapEphemeral: 21059;
+  readonly ClientAuth: 22242;
+  readonly NostrConnect: 24133;
+  readonly BlobsAuth: 24242;
+  readonly HttpAuth: 27235;
+  readonly RelaySets: 30002;
+  readonly EmojiSet: 30030;
+  readonly StarterPack: 39089;
+};
+type KindName = keyof typeof Kind;
+type KnownKind = (typeof Kind)[KindName];
+//#endregion
+export { SUBSCRIPTION_ID_MAX_CHARS as C, SIGNATURE_BYTES as S, utf8Decoder as _, classifyKind as a, PUBLIC_KEY_BYTES as b, isRegularKind as c, assertSecretKeyBytes as d, bytesToHex as f, normalizeURL as g, isHex64 as h, KnownKind as i, isReplaceableKind as l, isHex32 as m, KindClassification as n, isAddressableKind as o, hexToBytes as p, KindName as r, isEphemeralKind as s, Kind as t, assertHex32 as u, utf8Encoder as v, SECRET_KEY_BYTES as x, EVENT_ID_BYTES as y };
+//# sourceMappingURL=index-DaRyjo7O.d.mts.map

package/dist/index-DgOugrpF.d.mts

@@ -0,0 +1,275 @@
+import { n as EventTemplate, r as UnsignedEvent, t as Event } from "./event-B5D2jxt_.mjs";
+import { t as EventBuilder } from "./builder-BphJa-Y-.mjs";
+import { t as Filter } from "./filter-DUEKP3q1.mjs";
+import { t as Gossip } from "./gossip-C5RVB1UB.mjs";
+import { a as NostrError } from "./error-WEFS-R-4.mjs";
+import { i as PoolPublishResult, t as Pool, u as WebSocketConstructor } from "./pool-DhRi7l-b.mjs";
+import { a as OutboxFeed, n as Loaders } from "./index-EwL6fHLo.mjs";
+import { t as EventStore } from "./types-Dn24TPFs.mjs";
+import { a as Rumor } from "./nip59-DljW_sYh.mjs";
+import { i as ReplyTo, r as Recipient } from "./nip17-BWq-Kfq5.mjs";
+import { t as NostrSigner } from "./types-BzyADqnw.mjs";
+import { t as StorageError } from "./error-B49rbDzT.mjs";
+//#region src/client/builder.d.ts
+/** Fluent constructor for {@link Client}. */
+declare class ClientBuilder {
+  #private;
+  signer(signer: NostrSigner): this;
+  relays(urls: readonly string[]): this;
+  addRelay(url: string): this;
+  websocketImplementation(impl: WebSocketConstructor): this;
+  verifyEvent(fn: (event: Event) => boolean): this;
+  connectTimeoutMs(ms: number): this;
+  publishTimeoutMs(ms: number): this;
+  automaticAuth(enabled: boolean): this;
+  enableReconnect(enabled: boolean): this;
+  enablePing(enabled: boolean): this;
+  pingIntervalMs(ms: number): this;
+  pingTimeoutMs(ms: number): this;
+  /**
+   * Local event store. Defaults to {@link MemoryEventStore}.
+   * Browser apps that want persistence must pass {@link IndexedDbEventStore} and `await open()`.
+   */
+  storage(store: EventStore): this;
+  /** When false, Client will not auto-write events to storage. Default true. */
+  persistEvents(enabled: boolean): this;
+  gossip(gossip: Gossip): this;
+  onstorageerror(fn: (err: StorageError) => void): this;
+  build(): Client;
+}
+//#endregion
+//#region src/client/types.d.ts
+declare const SyncDirection: {
+  readonly Up: "up";
+  readonly Down: "down";
+  readonly Both: "both";
+};
+type SyncDirectionName = (typeof SyncDirection)[keyof typeof SyncDirection];
+type SyncOptions = {
+  relays?: readonly string[];
+  direction?: SyncDirectionName;
+  /**
+   * Wall-clock deadline for the Negentropy reconciliation session
+   * (`NEG-OPEN` through `NEG-CLOSE`), in milliseconds.
+   * One clock for the whole session — not reset per `NEG-MSG`.
+   * Default: the relay `publishTimeoutMs`.
+   * Upload/download phases reuse this value as their per-call timeout.
+   */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  dryRun?: boolean;
+  /** When false, skip observe/storage on downloaded events. Default true. */
+  observe?: boolean;
+};
+type SyncSummary = {
+  local: string[];
+  remote: string[];
+  sent: string[];
+  received: string[];
+  sendFailures: Record<string, string>;
+  persistFailures: Record<string, string>;
+};
+type ClientOptions = {
+  signer?: NostrSigner;
+  relays?: readonly string[];
+  websocketImplementation?: WebSocketConstructor;
+  /** Injected EVENT verifier. Default is core BIP-340. */
+  verifyEvent?: (event: Event) => boolean;
+  connectTimeoutMs?: number;
+  publishTimeoutMs?: number;
+  /** When true (default if signer present), answer NIP-42 AUTH automatically. */
+  automaticAuth?: boolean;
+  /** When true (default), relays reconnect with backoff after disconnect. */
+  enableReconnect?: boolean;
+  /** Keepalive ping. Default false. */
+  enablePing?: boolean;
+  pingIntervalMs?: number;
+  pingTimeoutMs?: number;
+  gossip?: Gossip;
+  /**
+   * Local event store. Defaults to {@link MemoryEventStore}.
+   * Browser apps that want persistence must pass {@link IndexedDbEventStore} and `await open()`.
+   */
+  storage?: EventStore;
+  /**
+   * When true (default), every ingested event is written to storage.
+   * Set false to disable automatic persistence while keeping the store for manual use.
+   */
+  persistEvents?: boolean;
+  /**
+   * Storage I/O failures: live `putMany` flush and `fetchEvents({ localFirst: true })` query.
+   * Those paths do not throw.
+   */
+  onstorageerror?: (err: StorageError) => void;
+};
+type FetchEventsOptions = {
+  relays?: string[];
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  gossip?: boolean;
+  /**
+   * When true, query local storage first and merge with network results.
+   * Defaults to false.
+   */
+  localFirst?: boolean;
+  /** When false, skip writing fetched events to storage/observe. Default true. */
+  observe?: boolean;
+};
+type SubscribeOptions = {
+  relays?: string[];
+  onevent?: (event: Event) => void;
+  oneose?: () => void;
+  onclose?: (reason: string) => void;
+  signal?: AbortSignal;
+  id?: string;
+  /**
+   * If set, fire `oneose` once after this many ms if not all relays have EOSEd.
+   * Does not close the subscription.
+   */
+  eoseTimeoutMs?: number;
+  /** Fan out REQs via NIP-65 gossip routes when available. */
+  gossip?: boolean;
+  /** When false, skip writing received events to storage/observe. Default true. */
+  observe?: boolean;
+};
+type PublishOptions = {
+  relays?: string[];
+  timeoutMs?: number;
+  gossip?: boolean;
+  /** When false, skip writing the published event to storage/observe. Default true. */
+  observe?: boolean;
+};
+type SendPrivateMessageOptions = {
+  readonly subject?: string;
+  readonly replyTo?: ReplyTo;
+  readonly created_at?: number;
+  readonly timeoutMs?: number;
+  readonly observe?: boolean;
+};
+type PrivateMessageSendResult = {
+  rumor: Rumor;
+  wraps: ReadonlyArray<{
+    recipient: string;
+    wrap: Event;
+    results: PoolPublishResult[];
+  }>;
+};
+type ReceivedPrivateMessage = {
+  wrap: Event;
+  rumor: Rumor;
+};
+type FetchPrivateMessagesOptions = {
+  readonly since?: number;
+  readonly until?: number;
+  readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
+  readonly observe?: boolean;
+};
+type SubscribePrivateMessagesOptions = {
+  readonly since?: number;
+  readonly onevent?: (msg: ReceivedPrivateMessage) => void;
+  readonly oneose?: () => void;
+  readonly onclose?: (reason: string) => void;
+  readonly signal?: AbortSignal;
+  readonly eoseTimeoutMs?: number;
+  readonly observe?: boolean;
+};
+/** Client lifecycle, configuration, or abort failure (not cryptographic). */
+declare class ClientError extends NostrError {}
+//#endregion
+//#region src/client/client.d.ts
+/**
+ * Layer-5 facade: signer + default relays + pool + loaders + gossip + event store.
+ */
+declare class Client {
+  #private;
+  readonly pool: Pool;
+  readonly loaders: Loaders;
+  readonly gossip: Gossip;
+  readonly storage: EventStore;
+  onstorageerror: ((err: StorageError) => void) | null;
+  constructor(opts?: ClientOptions);
+  static builder(): ClientBuilder;
+  get signer(): NostrSigner | undefined;
+  get relays(): readonly string[];
+  get isShutdown(): boolean;
+  setSigner(signer: NostrSigner): void;
+  addRelay(url: string): void;
+  removeRelay(url: string): void;
+  /** Connect all configured relays (best-effort; failures are ignored). */
+  connect(opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  shutdown(): Promise<void>;
+  /**
+   * Unified ingest pipeline: gossip + replaceable loader cache immediately;
+   * storage writes are coalesced into a single-flight `putMany`.
+   */
+  observe(event: Event): void;
+  /** Observe many events (deduped by id, order preserved) as one persist batch. */
+  observeAll(events: readonly Event[]): void;
+  /**
+   * Explicitly load kind:10002 and kind:10050 lists for pubkeys and feed gossip.
+   * Does not background-fetch unknown authors on every subscribe (predictable DX).
+   */
+  hydrateGossip(pubkeys: readonly string[], opts?: {
+    hints?: string[];
+    force?: boolean;
+  }): Promise<void>;
+  /**
+   * Create an outbox-model feed for the given authors (NIP-65 write relays).
+   * Live events go through {@link observe}; sync persists via applySync.
+   */
+  outbox(opts: {
+    authors: readonly string[];
+    kinds?: readonly number[];
+    onEvent?: (event: Event) => void;
+    maxRelaysPerAuthor?: number;
+  }): OutboxFeed;
+  getPublicKey(): Promise<string>;
+  signEvent(unsigned: UnsignedEvent): Promise<Event>;
+  signEventBuilder(builder: EventBuilder): Promise<Event>;
+  signTemplate(template: EventTemplate): Promise<Event>;
+  /**
+   * Sign (if builder) and publish to relays.
+   * With `gossip: true`, prefers the author's NIP-65 outbox relays, tagged `p`
+   * inboxes, and up to 5 `e`/`a` tag relay hints when known.
+   * On any successful OK, observes the event into storage/gossip.
+   */
+  publish(eventOrBuilder: Event | EventBuilder, opts?: PublishOptions): Promise<PoolPublishResult[]>;
+  /**
+   * Fetch events. With `gossip: true`, routes filters by NIP-65 when possible.
+   * With `localFirst: true`, merges storage hits with network results.
+   */
+  fetchEvents(filter: Filter | Filter[], opts?: FetchEventsOptions): Promise<Event[]>;
+  /**
+   * Query local storage only (no network).
+   */
+  queryLocal(filter: Filter | Filter[]): Promise<Event[]>;
+  subscribe(filter: Filter | Filter[], opts?: SubscribeOptions): {
+    close: (reason?: string) => void;
+  };
+  /** Publish a kind:10050 NIP-17 DM relay list (`relay` tags). Not kind 10002. */
+  setDmRelays(relays: readonly string[], opts?: PublishOptions): Promise<PoolPublishResult[]>;
+  sendPrivateMessage(recipients: string | Recipient | readonly (string | Recipient)[], content: string, opts?: SendPrivateMessageOptions): Promise<PrivateMessageSendResult>;
+  fetchPrivateMessages(opts?: FetchPrivateMessagesOptions): Promise<ReceivedPrivateMessage[]>;
+  subscribePrivateMessages(opts?: SubscribePrivateMessagesOptions): Promise<{
+    close: (reason?: string) => void;
+  }>;
+  /**
+   * NIP-77 sync against one relay: reconcile, then optionally upload
+   * local-only events and/or download remote-only events.
+   * `observe: false` skips putMany and ingestMeta; received ids are still listed.
+   * `persistEvents: false` skips putMany, still ingestMeta when observe is on.
+   */
+  syncToRelay(url: string, filter: Filter, opts?: Omit<SyncOptions, "relays">): Promise<SyncSummary>;
+  /**
+   * NIP-77 sync against the given relays (or Client default relays).
+   * Independent sessions run in parallel. Fulfilled summaries are merged;
+   * if every relay rejects, throws the first rejection in URL order.
+   */
+  sync(filter: Filter, opts?: SyncOptions): Promise<SyncSummary>;
+}
+//#endregion
+export { FetchPrivateMessagesOptions as a, ReceivedPrivateMessage as c, SubscribePrivateMessagesOptions as d, SyncDirection as f, ClientBuilder as g, SyncSummary as h, FetchEventsOptions as i, SendPrivateMessageOptions as l, SyncOptions as m, ClientError as n, PrivateMessageSendResult as o, SyncDirectionName as p, ClientOptions as r, PublishOptions as s, Client as t, SubscribeOptions as u };
+//# sourceMappingURL=index-DgOugrpF.d.mts.map