@v3finance/monitoring-sdk 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,16 +1,26 @@
 # Changelog
 
-All notable changes to this package. The format follows [Keep a Changelog](https://keepachangelog.com), versions —
-[SemVer](https://semver.org).
+All notable changes to this package are documented in this file. The format is based on
+[Keep a Changelog](https://keepachangelog.com), and this project adheres to [Semantic Versioning](https://semver.org).
 
-## 0.1.0 — 2026-10-28
+## 0.2.0 — 2026-10-28
+
+### Breaking changes
+
+- `MonitoringClient` authenticates with an API key only. Your client ID is resolved from the key, so methods no
+  longer take it as a parameter.
+- Removed account management APIs: `MonitoringClient.signIn`, `auth`, `account.keys` and `clients`.
+- `clients.sendTestWebhook()` is now `webhooks.sendTest()`.
+- `AddressDefaults` is renamed to `SubscriptionDefaults`, and `AddressSubscriptionUpdate` to `AddressUpdate`.
+
+### Added
 
-First release.
+- `account.get()` and `account.id()`.
+
+### Changed
+
+- Documentation and type descriptions are now in English.
+
+## 0.1.0 — 2026-10-28
 
-- `MonitoringClient`: account and personal keys, sign-in, networks and assets, your client (webhook URL, signing
-  secret, client keys, members, test webhook), addresses and subscriptions with automatic batching, webhook history,
-  transaction lookup with confirmations and finality.
-- Webhooks: `parseWebhook`, `verifyWebhookSignature`, `signWebhookBody`, `isTestWebhook`, `webhookIdempotencyKey`.
-- Amounts: `formatUnits`, `parseUnits`.
-- Timeouts, cancellation, retries on 429 and 503, typed errors with per-item details.
-- Types generated from the OpenAPI spec of the API.
+- Initial release.

package/README.md

@@ -1,145 +1,249 @@
-# @v3finance/monitoring-sdk
-
-Official TypeScript SDK for the [V3 Finance address monitoring API](https://monitoring.v3.finance/docs):
-watch addresses on TRON and EVM networks and receive a signed webhook for every incoming and outgoing transfer.
-
-- **Typed end to end** — request and response types are generated from the API's OpenAPI spec, with docs on hover.
-- **Webhooks** — signature verification and typed parsing with no network calls, using Web Crypto.
-- **Built for production** — timeouts, cancellation, retries on rate limits, typed errors with per-item details,
-  automatic batching of large address lists, async iteration over pages.
-- **Zero runtime dependencies** — Node.js 20+, Bun, Deno, Cloudflare Workers; ESM and CommonJS.
-
-[Русская версия ниже](#по-русски).
-
-## Install
+# V3 Finance Monitoring SDK
+
+[![npm version](https://img.shields.io/npm/v/@v3finance/monitoring-sdk.svg)](https://www.npmjs.com/package/@v3finance/monitoring-sdk)
+[![npm downloads](https://img.shields.io/npm/dm/@v3finance/monitoring-sdk.svg)](https://www.npmjs.com/package/@v3finance/monitoring-sdk)
+[![types](https://img.shields.io/npm/types/@v3finance/monitoring-sdk.svg)](https://www.npmjs.com/package/@v3finance/monitoring-sdk)
+[![license](https://img.shields.io/npm/l/@v3finance/monitoring-sdk.svg)](./LICENSE)
+
+The official TypeScript SDK for the [V3 Finance Monitoring API](https://monitoring.v3.finance/docs).
+Monitor addresses on TRON and EVM networks and receive a signed webhook for every incoming and outgoing transfer.
+
+- **Address monitoring** with per-address subscriptions: choose the assets and the direction you are notified about.
+- **Webhooks** with signature verification and fully typed payloads.
+- **Transaction lookup** with confirmations and finality, for any transaction on a supported network.
+- **Delivery history** of every webhook sent to you.
+- **Production-ready**: automatic retries, timeouts, cancellation, pagination and batching.
+- **Fully typed**, zero dependencies, ESM and CommonJS. Runs on Node.js, Bun, Deno and Cloudflare Workers.
+
+## Contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Configuration](#configuration)
+- [Addresses](#addresses)
+- [Receiving webhooks](#receiving-webhooks)
+- [Transactions and finality](#transactions-and-finality)
+- [Delivery history](#delivery-history)
+- [Networks and assets](#networks-and-assets)
+- [Amounts](#amounts)
+- [Error handling](#error-handling)
+- [Retries, timeouts and cancellation](#retries-timeouts-and-cancellation)
+- [TypeScript](#typescript)
+- [Requirements](#requirements)
+- [Security](#security)
+- [Versioning](#versioning)
+- [Support](#support)
+
+## Installation
 
 ```bash
 npm install @v3finance/monitoring-sdk
 ```
 
-Server-side only: an API key in a browser is visible to anyone.
+```bash
+pnpm add @v3finance/monitoring-sdk
+yarn add @v3finance/monitoring-sdk
+bun add @v3finance/monitoring-sdk
+```
 
 ## Quick start
 
 ```ts
 import { MonitoringClient } from '@v3finance/monitoring-sdk'
 
-const monitoring = new MonitoringClient({ apiKey: process.env.MONITORING_API_KEY })
+const monitoring = new MonitoringClient({ apiKey: process.env.MONITORING_API_KEY! })
+
+// Notify about incoming USDT on a deposit address
+await monitoring.addresses.add(
+  [{ network: 'tron', address: 'TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr', label: 'user-42' }],
+  { assets: ['USDT'], direction: 'in' },
+)
+```
+
+Every transfer on the address now triggers a signed webhook to your endpoint — see
+[Receiving webhooks](#receiving-webhooks).
 
-// your client id: for a client key it is in the key's identity
-const { actor } = await monitoring.account.me()
-const clientId = actor.clientId!
+## Configuration
 
-// deposit addresses: incoming USDT only
-await monitoring.addresses.add(clientId, [{ network: 'tron', address: 'TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr', label: 'user-42' }], {
-  assets: ['USDT'],
-  direction: 'in',
+```ts
+const monitoring = new MonitoringClient({
+  apiKey: process.env.MONITORING_API_KEY!,
+  timeoutMs: 10_000,
+  maxRetries: 3,
 })
 ```
 
-## Authentication
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `apiKey` | `string` | — | Your API key. **Required.** |
+| `clientId` | `string` | resolved from the API key | Your client ID. |
+| `baseUrl` | `string` | `https://monitoring.v3.finance` | API base URL. |
+| `timeoutMs` | `number` | `30000` | Request timeout in milliseconds. |
+| `maxRetries` | `number` | `2` | Retries for rate limits and transient errors. |
+| `fetch` | `typeof fetch` | global `fetch` | Custom `fetch` implementation. |
+| `headers` | `Record<string, string>` | — | Additional headers sent with every request. |
+
+## Addresses
 
-| Credential | How to get it | What it can do |
-|---|---|---|
-| Client key `ce_…` | panel → client → API keys, or `clients.keys.create()` | addresses, history and transactions of that client |
-| Personal key `ce_user_…` | panel → Account, or `account.keys.create()` after signing in | everything you can do in the panel, with your role |
-| Session | `MonitoringClient.signIn({ email, password })` | same as a personal key |
+An address is monitored on a single network; to watch an EVM address on several networks, add it once per network.
+Each address has a **subscription** — which assets (`assets`) and which direction (`direction`: `in`, `out` or
+`both`) you are notified about. By default it covers all assets of the network in both directions.
 
 ```ts
-const monitoring = new MonitoringClient({ apiKey: 'ce_…' })
-const { client } = await MonitoringClient.signIn({ email, password })
+// Add — lists larger than 1,000 addresses are sent in batches automatically
+await monitoring.addresses.add(
+  [
+    { network: 'tron', address: 'TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr', label: 'user-42' },
+    { network: 'ethereum', address: '0x533bcdd534fc3f9651471d7b4469a0d01ca45a2a', assets: ['USDT', 'USDC'] },
+  ],
+  { direction: 'in' },
+)
+
+// Change the subscription
+await monitoring.addresses.update([{ network: 'tron', address: 'TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr' }], { direction: 'both' })
+
+// Iterate over all monitored addresses
+for await (const address of monitoring.addresses.iterate({ network: 'tron' })) {
+  console.log(address.address, address.assets ?? 'all assets', address.direction)
+}
+
+// Stop monitoring
+await monitoring.addresses.remove([{ network: 'tron', address: 'TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr' }])
 ```
 
+Requests are validated as a whole: if any address is invalid for its network, nothing is changed and
+`error.details` lists the problems by index.
+
 ## Receiving webhooks
 
-Every webhook is a `POST` with JSON `{ tx: { network, asset, contract, type, id, block, timestamp, from, to, value, logIndex? } }`
-and an `x-signature` header — HMAC-SHA256 of the raw body with your client's secret. Verify it against the **raw**
-body: re-serialized JSON will not match.
+Every webhook is a `POST` request with a JSON body and an `x-signature` header — an HMAC-SHA256 of the raw body keyed
+with your webhook secret. `parseWebhook` verifies the signature and returns a typed payload.
+
+**Express**
 
 ```ts
 import express from 'express'
 import { isTestWebhook, parseWebhook, webhookIdempotencyKey, WebhookSignatureError } from '@v3finance/monitoring-sdk'
 
+const app = express()
+
 app.post('/webhooks/monitoring', express.raw({ type: 'application/json' }), async (req, res) => {
   try {
     const event = await parseWebhook(req.body, req.headers, process.env.MONITORING_WEBHOOK_SECRET!)
-    if (!isTestWebhook(event)) await creditOnce(webhookIdempotencyKey(event), event.tx)
+    if (!isTestWebhook(event)) {
+      await creditOnce(webhookIdempotencyKey(event), event.tx)
+    }
     res.sendStatus(200)
-  } catch (e) {
-    if (e instanceof WebhookSignatureError) return res.sendStatus(401)
-    throw e
+  } catch (error) {
+    if (error instanceof WebhookSignatureError) return res.sendStatus(401)
+    throw error
   }
 })
 ```
 
-Hono, Next.js route handlers, Cloudflare Workers:
+**Next.js (App Router)** — and any runtime built on the Fetch API: Cloudflare Workers, Bun, Deno
 
 ```ts
-const event = await parseWebhook(await request.text(), request.headers, env.MONITORING_WEBHOOK_SECRET)
+export async function POST(request: Request) {
+  const event = await parseWebhook(await request.text(), request.headers, process.env.MONITORING_WEBHOOK_SECRET!)
+  // …
+  return new Response(null, { status: 200 })
+}
 ```
 
-Rules of delivery:
+**Hono**
 
-- Answer **2xx within 15 seconds**; otherwise the webhook is retried after 10 s, 1 min and 5 min.
-- The same webhook can arrive more than once — process it idempotently by `webhookIdempotencyKey(event)`.
-- `type` is always `TOPUP` for both directions: compare `from` and `to` with your addresses.
-- A webhook is sent as soon as the transfer is in a block, before finality. For large amounts check
-  `final` first (below).
-- Test webhooks (`isTestWebhook(event)`, header `x-webhook-test: 1`) must not be credited.
+```ts
+app.post('/webhooks/monitoring', async (c) => {
+  const event = await parseWebhook(await c.req.text(), c.req.raw.headers, c.env.MONITORING_WEBHOOK_SECRET)
+  // …
+  return c.body(null, 200)
+})
+```
 
-## Transactions: confirmations and finality
+The payload:
+
+```json
+{
+  "tx": {
+    "network": "TRON",
+    "asset": "USDT",
+    "contract": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+    "type": "TOPUP",
+    "id": "1249cb7b7edd42072684b1db37ad495d4a5b7eefd1aff83e595e9bdb63a5fc45",
+    "block": 87445412,
+    "timestamp": 1793009472000,
+    "from": "TW9goADYcUxskhQQRifvwoRBUMHnmTh9MA",
+    "to": "TA8HgQbFjuMLWCaJeGyfrv8FErWSHz82vr",
+    "value": "100000000"
+  }
+}
+```
+
+Best practices:
 
-Any transaction by hash, not only the ones you got a webhook for:
+- **Verify against the raw body.** Parsing and re-serializing the JSON changes the bytes and breaks the signature.
+- **Respond quickly.** Return a 2xx status within 15 seconds; otherwise the webhook is retried after 10 seconds,
+  1 minute and 5 minutes.
+- **Process idempotently.** A webhook may be delivered more than once — deduplicate with `webhookIdempotencyKey(event)`.
+- **Check the direction.** `type` is `TOPUP` for both directions; compare `from` and `to` with your addresses.
+- **Wait for finality on large amounts.** Webhooks are sent as soon as a transfer is included in a block — see
+  [Transactions and finality](#transactions-and-finality).
+- **Ignore test webhooks** — `isTestWebhook(event)` is `true` for them.
+
+Send a test webhook to check your endpoint:
 
 ```ts
-const tx = await monitoring.transactions.get('tron', event.tx.id)
-tx.status        // 'success' | 'failed' | 'pending'
-tx.confirmations // from the current head of the network
-tx.final         // cannot be reverted: TRON — solidified (~1 min), Ethereum — finalized (~13 min)
-tx.transfers     // every transfer inside: native, tokens, TRON internal TRX transfers
-tx.watched       // your watched addresses in this transaction
-tx.webhooks      // webhooks we sent you for it
+const { delivery, signature, body } = await monitoring.webhooks.sendTest({ asset: 'USDT' })
+console.log(delivery.ok ? 'Delivered' : `Endpoint responded with ${delivery.status ?? delivery.error}`)
 ```
 
-## Addresses and subscriptions
+## Transactions and finality
+
+Look up any transaction on a supported network — not only the ones you were notified about.
 
 ```ts
-await monitoring.addresses.add(clientId, items, { assets: ['USDT'], direction: 'in' }) // more than 1000 — batched for you
-await monitoring.addresses.update(clientId, [{ network: 'tron', address: 'T…' }], { direction: 'both' })
-await monitoring.addresses.remove(clientId, [{ network: 'tron', address: 'T…' }])
+const tx = await monitoring.transactions.get('tron', event.tx.id)
 
-for await (const a of monitoring.addresses.iterate(clientId, { network: 'tron' })) {
-  console.log(a.address, a.assets ?? 'all assets', a.direction)
-}
+tx.status        // 'success' | 'failed' | 'pending'
+tx.confirmations // blocks since inclusion
+tx.final         // the transaction can no longer be reverted
+tx.fee           // { asset: 'TRX', value: '6773500' }
+tx.transfers     // every transfer inside the transaction
+tx.watched       // your monitored addresses involved
+tx.webhooks      // webhooks sent to you for this transaction
 ```
 
-A subscription narrows what you are notified about: `assets` — symbols or contract addresses (`null` — all assets of
-the network, including ones added later), `direction` — `in`, `out` or `both`. EVM addresses are per network: watch
-one address on several networks with several items.
+A transaction is final once its block is solidified on TRON (about 1 minute) or finalized on EVM networks (about
+13 minutes on Ethereum). Credit large amounts once `final` is `true`.
 
-## Webhook history
+## Delivery history
+
+Every webhook sent to you is recorded with its status, attempts and your endpoint's response, and kept for 90 days.
 
 ```ts
-for await (const d of monitoring.deliveries.iterate(clientId, { status: 'failed', since: new Date(Date.now() - 86_400_000) })) {
-  console.log(d.txId, d.attempts, d.lastHttpStatus ?? d.lastError)
+for await (const delivery of monitoring.deliveries.iterate({ status: 'failed', since: new Date(Date.now() - 86_400_000) })) {
+  console.log(delivery.txId, delivery.attempts, delivery.lastHttpStatus ?? delivery.lastError)
 }
-const detail = await monitoring.deliveries.get(clientId, id) // exact body and URL
+
+const detail = await monitoring.deliveries.get(deliveryId) // includes the exact request body
 ```
 
-## Your client
+Filter by `status` (`delivered`, `retrying`, `failed`), `network`, `asset`, `tx`, `address`, `since` and `until`.
 
-Owner and admin of a client (session or personal key):
+## Networks and assets
 
 ```ts
-await monitoring.clients.update(clientId, { webhookUrl: 'https://example.com/webhooks/monitoring' })
-const { secretKey } = await monitoring.clients.rotateSecret(clientId) // the old secret stops working at once
-const { key } = await monitoring.clients.keys.create(clientId, { name: 'backend', expiresInDays: 365 })
-const result = await monitoring.clients.sendTestWebhook(clientId, { asset: 'USDT' }) // result.delivery.ok
+const networks = await monitoring.networks.list()
+const assets = await monitoring.assets.list({ network: 'tron' })
 ```
 
+You are notified about transfers of enabled assets of at least the asset's `minAmount`.
+
 ## Amounts
 
-Amounts are strings in minimal units (sun, wei; USDT has 6 decimals). Convert without losing precision:
+Amounts are strings in the asset's smallest unit (sun, wei; USDT has 6 decimals). Convert them without losing
+precision:
 
 ```ts
 import { formatUnits, parseUnits } from '@v3finance/monitoring-sdk'
@@ -148,101 +252,72 @@ formatUnits('100000000', 6) // '100'
 parseUnits('1.5', 6)        // '1500000'
 ```
 
-Decimals of every asset: `monitoring.assets.list()`.
+## Error handling
 
-## Errors, retries, timeouts
+All errors extend `MonitoringError`.
+
+| Error | When |
+|---|---|
+| `MonitoringApiError` | The API responded with an error. Has `status`, `code`, `details` and `requestId`. |
+| `MonitoringConnectionError` | The request failed to reach the API. |
+| `MonitoringTimeoutError` | The request exceeded `timeoutMs`. |
+| `WebhookSignatureError` | A webhook signature does not match. |
 
 ```ts
-import { MonitoringApiError, MonitoringConnectionError } from '@v3finance/monitoring-sdk'
+import { MonitoringApiError } from '@v3finance/monitoring-sdk'
 
 try {
-  await monitoring.addresses.add(clientId, items)
-} catch (e) {
-  if (e instanceof MonitoringApiError) {
-    e.status    // 400
-    e.code      // 'invalid_request'
-    e.details   // [{ index: 3, message: 'not a valid TRON address' }]
-    e.requestId // send it to support
+  await monitoring.addresses.add(items)
+} catch (error) {
+  if (error instanceof MonitoringApiError && error.status === 400) {
+    for (const { index, message } of error.details) console.error(`Item ${index}: ${message}`)
+  } else {
+    throw error
   }
 }
 ```
 
-- `429` and `503` are retried with the server's `Retry-After` or exponential backoff (`maxRetries`, default 2).
-  Network errors are retried only for requests that are safe to repeat.
-- Every request has a timeout (`timeoutMs`, default 30 s) and accepts an `AbortSignal`:
-  `monitoring.addresses.list(clientId, {}, { signal })`.
-- All errors extend `MonitoringError`.
-
-## API reference
-
-- Interactive reference: https://monitoring.v3.finance/docs
-- OpenAPI 3.1: https://monitoring.v3.finance/openapi.json
-- All request and response types are exported: `import type { Transaction, WebhookPayload } from '@v3finance/monitoring-sdk'`.
-
-## Versioning
-
-[SemVer](https://semver.org). While the version is `0.x`, minor releases may contain breaking changes; they are listed in
-[CHANGELOG.md](./CHANGELOG.md).
-
----
+## Retries, timeouts and cancellation
 
-## По-русски
-
-Официальный SDK API мониторинга адресов V3 Finance: адреса в TRON и EVM-сетях, подписанные вебхуки о переводах,
-история доставок, транзакции с подтверждениями и финальностью. Подсказки в редакторе — по-русски.
-
-```bash
-npm install @v3finance/monitoring-sdk
-```
-
-**Только для сервера** — ключ в браузере увидит любой. Node.js 20+, Bun, Deno, Cloudflare Workers; ESM и CommonJS.
+Rate-limited (`429`) and temporarily unavailable (`503`) requests are retried automatically with exponential backoff,
+honoring `Retry-After`. Network errors are retried only for requests that are safe to repeat. Configure this with
+`maxRetries` and `timeoutMs`, globally or per request:
 
 ```ts
-import { MonitoringClient, parseWebhook, isTestWebhook, webhookIdempotencyKey } from '@v3finance/monitoring-sdk'
+const controller = new AbortController()
 
-const monitoring = new MonitoringClient({ apiKey: process.env.MONITORING_API_KEY }) // ключ клиента ce_…
-const clientId = (await monitoring.account.me()).actor.clientId!
+await monitoring.addresses.list({ network: 'tron' }, { timeoutMs: 5_000, maxRetries: 0, signal: controller.signal })
+```
 
-// депозитные адреса: только входящие USDT
-await monitoring.addresses.add(clientId, [{ network: 'tron', address: 'T…', label: 'user-42' }], { assets: ['USDT'], direction: 'in' })
+## TypeScript
 
-// приём вебхука: подпись — по сырому телу
-const event = await parseWebhook(rawBody, headers, process.env.MONITORING_WEBHOOK_SECRET!)
-if (!isTestWebhook(event)) await creditOnce(webhookIdempotencyKey(event), event.tx)
+The SDK is written in TypeScript and ships its own type declarations. All request and response types are exported:
 
-// перед зачислением крупной суммы — финальность
-const tx = await monitoring.transactions.get('tron', event.tx.id)
-if (tx.status === 'success' && tx.final) { /* зачислить */ }
+```ts
+import type { Address, Delivery, Transaction, WebhookPayload } from '@v3finance/monitoring-sdk'
 ```
 
-Главное при приёме вебхуков:
+## Requirements
+
+- Node.js 20 or later, Bun, Deno or Cloudflare Workers.
+- ESM (`import`) and CommonJS (`require`) are both supported.
 
-- отвечайте **2xx за 15 секунд**, иначе повторы через 10 с, 1 мин и 5 мин;
-- один вебхук может прийти повторно — обрабатывайте идемпотентно по `webhookIdempotencyKey(event)`;
-- `type` всегда `TOPUP` — направление определяйте по `from` и `to`;
-- вебхук уходит сразу, как перевод попал в блок, до финальности: крупные суммы зачисляйте после `final`;
-- тестовые вебхуки (`isTestWebhook`, заголовок `x-webhook-test: 1`) не зачислять.
+## Security
 
-Ключи: **ключ клиента** `ce_…` — адреса, история и транзакции своего клиента; **личный ключ** `ce_user_…` — всё, что вы
-можете в панели (URL вебхука, секрет, ключи клиента, тестовый вебхук). Ошибки — `MonitoringApiError` со статусом, кодом
-и ошибками по элементам (`details`); повторы при 429 и 503, таймауты и отмена через `AbortSignal` — встроены.
-Суммы — строки в минимальных единицах: `formatUnits('100000000', 6) === '100'`.
+- Use the SDK on your servers only. Never expose your API key or webhook secret to browsers or mobile apps.
+- Keep credentials in environment variables or a secrets manager, not in source code.
+- Always verify webhook signatures before processing a webhook.
 
-Справочник API: https://monitoring.v3.finance/docs.
+## Versioning
 
-## Development
+This package follows [Semantic Versioning](https://semver.org). Changes are listed in [CHANGELOG.md](./CHANGELOG.md).
 
-```bash
-npm install
-npm run spec:update   # snapshot of https://monitoring.v3.finance/openapi.json → openapi/openapi.json
-npm run generate      # → src/generated/types.ts
-npm run typecheck && npm test && npm run build
-npm run build && MONITORING_API_KEY=ce_… node scripts/smoke.ts   # against the real API, with a client key
-```
+## Support
 
-Releases: bump `version` in `package.json` and `src/version.ts`, update `CHANGELOG.md`, publish a GitHub release
-`vX.Y.Z` — the `publish` workflow publishes to npm with Trusted Publishing.
+- API reference: [monitoring.v3.finance/docs](https://monitoring.v3.finance/docs)
+- OpenAPI specification: [monitoring.v3.finance/openapi.json](https://monitoring.v3.finance/openapi.json)
+- For access and support, contact your V3 Finance account manager.
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](./LICENSE) © V3 Finance

package/dist/cjs/client.d.ts

@@ -1,65 +1,46 @@
-import { type ClientOptions, type RequestOptions } from './core/http.js';
-import { AccountResource, AuthResource, type SignInResult } from './resources/account.js';
+import { type ClientOptions } from './core/http.js';
+import { AccountResource } from './resources/account.js';
 import { AddressesResource } from './resources/addresses.js';
 import { AssetsResource, NetworksResource } from './resources/catalog.js';
-import { ClientsResource } from './resources/clients.js';
 import { DeliveriesResource } from './resources/deliveries.js';
 import { TransactionsResource } from './resources/transactions.js';
+import { WebhooksResource } from './resources/webhooks.js';
 /**
- * Клиент API мониторинга адресов V3 Finance: адреса и подписки, история вебхуков, транзакции, ваш клиент и ключи.
- * Только для сервера: ключ в браузере увидит любой.
+ * Client for the V3 Finance Monitoring API.
  *
- * @example С ключом клиента — для бэкенда
+ * Use it on the server only: an API key in a browser is visible to anyone.
+ *
+ * @example
  * ```ts
  * import { MonitoringClient } from '@v3finance/monitoring-sdk'
  *
- * const monitoring = new MonitoringClient({ apiKey: process.env.MONITORING_API_KEY })
- * await monitoring.addresses.add(clientId, [{ network: 'tron', address: 'T…' }], { assets: ['USDT'], direction: 'in' })
- * ```
+ * const monitoring = new MonitoringClient({ apiKey: process.env.MONITORING_API_KEY! })
  *
- * @example По паролю — для скриптов, которым нужны права пользователя
- * ```ts
- * const { client } = await MonitoringClient.signIn({ email, password })
- * const { key } = await client.account.keys.create({ name: 'ci' })
+ * await monitoring.addresses.add([{ network: 'tron', address: 'TA8Hg…' }], { assets: ['USDT'], direction: 'in' })
  * ```
  */
 export declare class MonitoringClient {
     #private;
-    /** Кто вы и ваши личные ключи */
+    /** Your client: the account your API key belongs to. */
     readonly account: AccountResource;
-    /** Выход и смена пароля (для клиента, вошедшего по паролю) */
-    readonly auth: AuthResource;
-    /** Сети */
-    readonly networks: NetworksResource;
-    /** Нативные монеты и токены */
-    readonly assets: AssetsResource;
-    /** Ваш клиент: URL вебхука, секрет, ключи, участники, тестовый вебхук */
-    readonly clients: ClientsResource;
-    /** Адреса на мониторинге и подписка */
+    /** Addresses you monitor and their subscriptions. */
     readonly addresses: AddressesResource;
-    /** История вебхуков */
+    /** Test your webhook endpoint. */
+    readonly webhooks: WebhooksResource;
+    /** History of webhooks sent to you. */
     readonly deliveries: DeliveriesResource;
-    /** Транзакция по хешу: статус, подтверждения, финальность */
+    /** Any transaction by hash, with confirmations and finality. */
     readonly transactions: TransactionsResource;
+    /** Supported networks. */
+    readonly networks: NetworksResource;
+    /** Supported native coins and tokens. */
+    readonly assets: AssetsResource;
     /**
-     * @param options - ключ (`apiKey`) или токен сессии (`sessionToken`), адрес API, таймаут, повторы
-     * @throws {@link MonitoringError} переданы и ключ, и токен; нет `fetch`
+     * @param options - API key and optional settings.
+     * @throws {@link MonitoringError} when `apiKey` is missing or `fetch` is not available.
      */
-    constructor(options?: ClientOptions);
-    /** Адрес API, с которым работает клиент */
+    constructor(options: ClientOptions);
+    /** API base URL this client sends requests to. */
     get baseUrl(): string;
-    /**
-     * Вход по email и паролю: возвращает клиента с токеном сессии. Регистрации нет — пользователей заводит
-     * администратор сервиса. Не больше 3 попыток за 10 секунд с одного IP.
-     *
-     * @param options - настройки клиента, кроме учётных данных
-     * @throws {@link MonitoringApiError} 401 — неверный email или пароль
-     */
-    static signIn(credentials: {
-        email: string;
-        password: string;
-    }, options?: Omit<ClientOptions, 'apiKey' | 'sessionToken'>, requestOptions?: RequestOptions): Promise<SignInResult & {
-        client: MonitoringClient;
-    }>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/cjs/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpF,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGlE;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,gBAAgB;;IAC3B,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,WAAW;IACX,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;IACrC,uBAAuB;IACvB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAA;IACvC,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAA;IAI3C;;;OAGG;IACH,YAAY,OAAO,GAAE,aAAkB,EAUtC;IAED,2CAA2C;IAC3C,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;;;OAMG;IACH,OAAa,MAAM,CACjB,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAChD,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,cAAc,CAAM,EAC5D,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC,YAAY,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE,CAAC,CAYtD;CACF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAGpE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAG1D;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,qDAAqD;IACrD,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;IACrC,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,uCAAuC;IACvC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAA;IACvC,gEAAgE;IAChE,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAA;IAC3C,0BAA0B;IAC1B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAK/B;;;OAGG;IACH,YAAY,OAAO,EAAE,aAAa,EAWjC;IAED,kDAAkD;IAClD,IAAI,OAAO,IAAI,MAAM,CAEpB;CAiBF"}