@isnap/sdk 0.1.0 → 1.1.0-next.49

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to `@isnap/sdk` will be documented in this file. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Pre-1.0 versions may introduce breaking changes between 0.x → 0.(x+1) minor bumps.
+
+## [Unreleased]
+
+### Added
+- Initial public surface targeting iSnap API contract `v1.0.0`.
+- `ISnapClient` with retries (jittered exponential backoff on 429/5xx), per-attempt timeout, auto-`Idempotency-Key` for mutating verbs, header injection, abortable requests.
+- Resource classes: `messages`, `chats`, `lines`, `lookup`, `attachments`, `webhooks`, `byod`, `trial`.
+- `attachments.upload()` — transparent 3-step (POST register → presigned R2 PUT → poll until `ready`) with 5 GB cap and four typed failure modes.
+- Cursor pagination as `AsyncIterable` with optional `AbortSignal` on `messages.list`, `webhooks.deliveries`, `webhooks.events`.
+- Webhook helpers: `verifyWebhook` (HMAC-SHA256 + 5min replay window + multi-secret rotation), `parseWebhookEvent`, prefix-based type guards (`isMessageEvent`, `isReactionEvent`, `isLineEvent`, `isTypingEvent`, `isTrialEvent`).
+- Error hierarchy mirroring contract §6: `APIError` + 13 subclasses, all carrying `status`, `code`, `traceId`, `requestId`. Connection failures surface as `APIConnectionError` with native `Error.cause`.
+- Generated TypeScript types (`src/generated/openapi.d.ts`) compiled from the backend's frozen `openapi.json`.

package/README.md

@@ -1,236 +1,242 @@
 # @isnap/sdk
 
-[![CI](https://github.com/isnap-dev/isnap-node/actions/workflows/ci.yml/badge.svg)](https://github.com/isnap-dev/isnap-node/actions/workflows/ci.yml)
-[![npm version](https://img.shields.io/npm/v/@isnap/sdk.svg)](https://www.npmjs.com/package/@isnap/sdk)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+Official TypeScript SDK for the [iSnap](https://isnap.ai) P2P telephony API — real iMessage / SMS / RCS lines from real handsets, exposed as a single typed client.
 
-Official Node.js/TypeScript SDK for the [iSnap](https://isnap.dev) messaging API. Zero runtime dependencies.
+> Pre-1.0. Targets contract `docs/api-contract.md` v1.0.0. Public surface is stable across the v0.x line; breaking changes will bump 0.x → 0.(x+1) until 1.0.0.
 
-## Installation
+## Install
 
 ```bash
+bun add @isnap/sdk
+# or
 npm install @isnap/sdk
 ```
 
-## Quick Start
+Requires Node 20+ (or Bun 1.2+). The SDK uses native `fetch`, `node:crypto`, and ES2022 `Error.cause` — no polyfills.
+
+## Quick start
 
 ```ts
-import { init } from '@isnap/sdk';
+import { ISnapClient } from '@isnap/sdk'
 
-const client = init({ apiKey: 'isnap_your_api_key' });
+const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY! })
 
-const msg = await client.messages.send({
-  line_id: 'ln-1',
+const message = await client.messages.send({
+  line_id: 'line_01HX...',
   to: '+15551234567',
-  body: 'Hello from iSnap!',
-});
+  body: 'Hello from iSnap'
+})
 
-console.log(msg.id, msg.status);
+console.log(message.id, message.status)
 ```
 
-## Messages
+## Configuration
 
 ```ts
-// Send a message
-const msg = await client.messages.send({
-  line_id: 'ln-1',
-  to: '+15551234567',
-  body: 'Hello!',
-  channel: 'sms',              // optional: 'auto' | 'imessage' | 'sms' | 'whatsapp'
-  webhook_url: 'https://...',  // optional: delivery status callback
-  metadata: { order_id: '42' },
-});
-
-// Get a message by ID
-const message = await client.messages.get('msg-abc123');
-
-// List messages with filters
-const { messages, total } = await client.messages.list({
-  status: 'delivered',
-  direction: 'outbound',
-  page: 1,
-  limit: 50,
-});
-
-// List conversations
-const { conversations } = await client.messages.listConversations({
-  line_id: 'ln-1',
-});
-
-// Get a full conversation thread
-const thread = await client.messages.getConversation('conv-abc123', {
-  page: 1,
-  limit: 25,
-});
-console.log(thread.conversation.contact_number);
-console.log(thread.messages);
+new ISnapClient({
+  apiKey: 'sk_live_...',          // required
+  baseUrl: 'https://api.isnap.ai', // default
+  maxRetries: 3,                  // default 3 — retries on 429/5xx with jittered backoff
+  timeoutMs: 30_000,              // per-attempt timeout
+  idempotencyKey: 'auto',         // 'auto' generates UUIDs for POST/PATCH/PUT/DELETE; 'manual' = pass via opts
+  fetch: undefined,               // override (e.g. an instrumented fetch)
+  onRetry: (info) => console.warn('retry', info)
+})
 ```
 
-## Lines
+Every resource method accepts an optional `RequestOptions` final argument: `{ signal, idempotencyKey, headers, query, maxRetries }`.
+
+## Resources
+
+| Resource | What it does |
+|---|---|
+| `client.messages` | Send / get / cancel / list messages, add reactions |
+| `client.chats` | Mark a chat read, send typing indicators, share a contact card |
+| `client.lines` | List, configure, and inspect rented + BYOD lines, plus quota and queue snapshots |
+| `client.lookup` | Test if a number is iMessage-capable before sending |
+| `client.attachments` | Upload images / video / files (transparent 3-step flow) |
+| `client.webhooks` | CRUD subscriptions, rotate secrets, list deliveries, replay events |
+| `client.byod` | Pair a customer-owned Mac+iPhone or Android device |
+| `client.trial` | Start, check, and convert trial sessions |
+
+## Sending a message
 
 ```ts
-// List lines with filters
-const { lines } = await client.lines.list({
-  type: 'iphone',
-  area_code: '415',
-});
-
-// Get a line by ID
-const line = await client.lines.get('ln-abc123');
-console.log(line.phone_number, line.status);
+const msg = await client.messages.send({
+  line_id: 'line_01HX...',
+  to: '+15551234567',
+  body: 'Order #1242 is on its way',
+  service: 'iMessage' // optional — falls back to SMS/RCS via the line's degradation chain
+})
 ```
 
-## Webhooks
+`messages.send` is **idempotent by default** — the SDK auto-generates an `Idempotency-Key` for every POST. Retrying the same call with the same key returns the original message without sending a duplicate.
 
-### Managing webhook endpoints
+## Listing with cursor pagination
+
+`list()` returns an `AsyncIterable` that threads cursors automatically:
 
 ```ts
-// Create a webhook
-const wh = await client.webhooks.create({
-  url: 'https://example.com/webhooks/isnap',
-  events: ['message.sent', 'message.delivered', 'message.received'],
-});
-// Save wh.secret for signature verification
-
-// List webhooks
-const { webhooks } = await client.webhooks.list();
-
-// Delete a webhook
-await client.webhooks.delete('wh-abc123');
+for await (const msg of client.messages.list({ line_id: 'line_01HX...', limit: 100 })) {
+  console.log(msg.id, msg.created_at)
+}
 ```
 
-### Receiving webhooks
-
-Use `parseWebhook` to verify signatures and get typed events in one call:
+To stop early, pass an `AbortSignal`. Aborting surfaces as a thrown `APIConnectionError` on the next page boundary, so wrap the loop:
 
 ```ts
-import { parseWebhook } from '@isnap/sdk';
-// or: import { parseWebhook } from '@isnap/sdk/webhooks';
-
-app.post('/webhooks/isnap', express.text({ type: '*/*' }), (req, res) => {
-  const { verified, event } = parseWebhook({
-    secret: process.env.WEBHOOK_SECRET!,
-    signature: req.headers['x-isnap-signature'] as string,
-    timestamp: req.headers['x-isnap-timestamp'] as string,
-    body: req.body,
-  });
-
-  if (!verified) return res.status(401).send('Invalid signature');
-
-  switch (event.event) {
-    case 'message.sent':
-      console.log('Sent:', event.data.id);
-      break;
-    case 'message.delivered':
-      console.log('Delivered:', event.data.id);
-      break;
-    case 'message.received':
-      console.log('Inbound:', event.data.from_number, event.data.body);
-      break;
-    case 'message.read':
-      console.log('Read:', event.data.id);
-      break;
-    case 'message.failed':
-      console.log('Failed:', event.data.id, event.data.error_message);
-      break;
-  }
+import { APIConnectionError } from '@isnap/sdk'
+
+const ac = new AbortController()
+setTimeout(() => ac.abort(), 5_000)
 
-  res.sendStatus(200);
-});
+try {
+  for await (const msg of client.messages.list({}, { signal: ac.signal })) {
+    // ...
+  }
+} catch (err) {
+  if (!(err instanceof APIConnectionError)) throw err
+  // expected — signal aborted the iterator
+}
 ```
 
-You can also verify signatures manually:
+## Uploading an attachment
+
+`attachments.upload()` wraps the 3-step contract (register → presigned PUT → poll) into one call:
 
 ```ts
-import { verifyWebhookSignature } from '@isnap/sdk';
-
-const valid = verifyWebhookSignature(
-  secret,
-  req.headers['x-isnap-signature'],
-  req.headers['x-isnap-timestamp'],
-  req.body,
-);
+import { readFile } from 'node:fs/promises'
+
+const file = await readFile('./photo.jpg')
+
+const attachment = await client.attachments.upload(file, {
+  filename: 'photo.jpg',
+  contentType: 'image/jpeg'
+})
+
+await client.messages.send({
+  line_id: 'line_01HX...',
+  to: '+15551234567',
+  body: 'Here you go',
+  attachment_ids: [attachment.id]
+})
 ```
 
-## Pagination
+5 GB cap. Four documented failure modes — note that the R2 PUT and the server-side `failed` transition share the same `upload_failed` code:
+
+| Failure | `code` |
+|---|---|
+| `size_bytes` exceeds the 5 GB cap | `attachment_exceeds_storage_limit` |
+| R2 presigned PUT returns non-2xx | `upload_failed` |
+| Server transitions to `status: failed` | `upload_failed` |
+| Polling exhausted before `status: ready` | `upload_timeout` |
 
-Use the `paginate` async generator to iterate over large collections:
+## Verifying webhooks
 
 ```ts
-import { init, paginate } from '@isnap/sdk';
+import { verifyWebhook, isMessageEvent } from '@isnap/sdk'
 
-const client = init({ apiKey: 'isnap_your_key' });
+// Express / Hono / native handler — give us the RAW body bytes (string).
+async function handle(rawBody: string, headers: Record<string, string>) {
+  const event = verifyWebhook(rawBody, headers, process.env.ISNAP_WEBHOOK_SECRET!)
 
-// Iterate over all delivered messages
-for await (const msg of paginate(
-  (p) => client.messages.list(p),
-  { status: 'delivered' },
-  'messages',
-)) {
-  console.log(msg.id, msg.body);
-}
+  // Dedupe by event_id — delivery is at-least-once.
+  if (await alreadyProcessed(event.event_id)) return
 
-// Iterate over all conversations
-for await (const conv of paginate(
-  (p) => client.messages.listConversations(p),
-  { line_id: 'ln-1' },
-  'conversations',
-)) {
-  console.log(conv.contact_number, conv.message_count);
+  if (isMessageEvent(event)) {
+    console.log(event.event_type, event.data.message.id)
+  }
 }
 ```
 
-## Error Handling
+During a `rotate-secret` grace window pass both secrets:
+
+```ts
+verifyWebhook(rawBody, headers, [newSecret, oldSecret])
+```
+
+Throws `WebhookSignatureError` on missing headers, expired timestamp (5min tolerance), or signature mismatch.
+
+If verification happens behind a trusted gateway, use `parseWebhookEvent(rawBody)` to skip HMAC and just type the envelope.
+
+## Errors
+
+All API errors extend `APIError` and carry `status`, `code`, `message`, `traceId`, `requestId`. Subclasses match the §6 contract codes:
 
 ```ts
-import { iSnapError, RateLimitError } from '@isnap/sdk';
+import {
+  APIError,
+  APIConnectionError,
+  AuthenticationError,
+  BadRequestError,
+  ConflictError,
+  GoneError,
+  InternalServerError,
+  NotFoundError,
+  PaymentRequiredError,
+  PermissionDeniedError,
+  QuotaExceededError,
+  RateLimitError,
+  ServiceUnavailableError,
+  UnprocessableEntityError,
+  WebhookSignatureError
+} from '@isnap/sdk'
 
 try {
-  await client.messages.send({ line_id: 'ln-1', to: '+15551234567', body: 'Hello' });
+  await client.messages.send({
+    line_id: 'line_01HX...',
+    to: '+15551234567',
+    body: 'hello'
+  })
 } catch (err) {
   if (err instanceof RateLimitError) {
-    console.log(`Rate limited — retry after ${err.retryAfter}s`);
-  } else if (err instanceof iSnapError) {
-    console.log(`API error ${err.statusCode}: ${err.message} (${err.code})`);
+    // retry-after handled automatically by the retry loop, but visible here too
+  } else if (err instanceof QuotaExceededError) {
+    // pause sending until next quota window
+  } else if (err instanceof APIError) {
+    console.error(err.status, err.code, err.traceId)
+  } else if (err instanceof APIConnectionError) {
+    // network issue / timeout — already retried per `maxRetries`
+  } else {
+    throw err
   }
 }
 ```
 
-### Retry configuration
+Retries: 429 + 5xx are retried automatically with jittered exponential backoff up to `maxRetries`. The retry budget is per-call.
 
-The client automatically retries on 429 responses. Customize the behavior:
+## Examples
 
-```ts
-const client = init({
-  apiKey: 'isnap_your_key',
-  maxRetries: 5,        // default: 3
-  retryDelayMs: 2000,   // default: 5000 (fallback when no Retry-After header)
-});
-```
+Runnable scripts in [`examples/`](https://github.com/WhatSnap/iSnap-App/tree/main/packages/sdk/examples) (browse on GitHub — they live in the repo, not the published tarball):
 
-## TypeScript
+- `send-message.ts` — minimal send
+- `paginate-messages.ts` — async iterator + abort
+- `upload-attachment.ts` — file upload + send with attachment
+- `handle-webhook.ts` — `node:http` server that verifies and dispatches events
 
-All types are exported from the main entry point:
+Run them against a local backend:
 
-```ts
-import type {
-  Message,
-  SendMessageParams,
-  Line,
-  Webhook,
-  Conversation,
-  ConversationThreadResponse,
-  WebhookEvent,
-  WebhookEventType,
-  MessageSentEvent,
-  iSnapConfig,
-} from '@isnap/sdk';
+```bash
+ISNAP_API_KEY=sk_test_... bun run examples/send-message.ts
+```
+
+## Development
+
+```bash
+bun install
+bun run --filter '@isnap/sdk' test
+bun run --filter '@isnap/sdk' typecheck
+bun run --filter '@isnap/sdk' lint
+bun run --filter '@isnap/sdk' build
 ```
 
-## Contributing
+To regenerate types from the backend's frozen OpenAPI spec:
 
-Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+```bash
+bun run --filter '@isnap/backend' dump-openapi   # writes packages/backend/openapi.json
+bun run --filter '@isnap/sdk' generate           # regenerates src/generated/openapi.d.ts
+```
 
 ## License
 
-[MIT](LICENSE)
+MIT

package/dist/client.d.ts

@@ -1,61 +1,59 @@
-import type { iSnapConfig } from './types.js';
-import { MessagesResource } from './resources/messages.js';
+import { type ClientConfig } from './config.js';
+import { AttachmentsResource } from './resources/attachments.js';
+import { ByodResource } from './resources/byod.js';
+import { ChatsResource } from './resources/chats.js';
 import { LinesResource } from './resources/lines.js';
+import { LookupResource } from './resources/lookup.js';
+import { MessagesResource } from './resources/messages.js';
+import { TrialResource } from './resources/trial.js';
 import { WebhooksResource } from './resources/webhooks.js';
+import type { HttpMethod, RequestOptions } from './types.js';
 /**
- * The iSnap SDK client. Provides access to all API resources.
- *
- * @example
- * ```ts
- * import { init } from '@isnap/sdk';
+ * Test-only escape hatch to clear the per-process dedup set between test
+ * cases. Not part of the public stability contract — flagged @internal so
+ * IDE auto-import doesn't surface it to consumers.
  *
- * const client = init({ apiKey: 'isnap_your_key' });
- * const msg = await client.messages.send({ line_id: 'ln-1', to: '+15551234567', body: 'Hello' });
- * ```
+ * @internal
  */
-export declare class iSnapClient {
-    private apiKey;
-    private baseUrl;
-    private maxRetries;
-    private retryDelayMs;
-    /** Message sending, retrieval, and conversation management. */
-    messages: MessagesResource;
-    /** Phone line listing and lookup. */
-    lines: LinesResource;
-    /** Webhook endpoint management. */
-    webhooks: WebhooksResource;
-    constructor(config: iSnapConfig);
+export declare function _resetDeprecationWarnings(): void;
+export declare class ISnapClient {
+    private readonly config;
+    readonly attachments: AttachmentsResource;
+    readonly byod: ByodResource;
+    readonly chats: ChatsResource;
+    readonly lines: LinesResource;
+    readonly lookup: LookupResource;
+    readonly messages: MessagesResource;
+    readonly trial: TrialResource;
+    readonly webhooks: WebhooksResource;
+    constructor(config: ClientConfig);
     /**
-     * Send an HTTP request to the iSnap API.
+     * Direct fetch with no SDK auth, no envelope parsing, no retry — used
+     * internally by resource methods that must call URLs OUTSIDE the iSnap
+     * API surface (e.g. presigned R2 PUTs during `attachments.upload`).
      *
-     * Handles authorization, JSON serialization, rate-limit retries, and error mapping.
+     * The leading underscore signals "internal but unavoidably public": it
+     * lives on the public class because resource classes cannot reach the
+     * private `config.fetch` otherwise. SDK consumers should use the typed
+     * resource methods or `request()` for everything in `/v1/*` — calling
+     * this directly bypasses the SDK contract.
      *
-     * @param method - HTTP method (GET, POST, DELETE, etc.)
-     * @param path - API path (e.g. `/v1/messages`)
-     * @param body - Optional request body (will be JSON-stringified)
-     * @param query - Optional query parameters
-     * @returns Parsed JSON response
-     * @throws {iSnapError} On non-2xx responses
-     * @throws {RateLimitError} When rate-limited after exhausting retries
+     * Applies the same `config.timeoutMs` ceiling as `request()` so a
+     * stalled R2 PUT cannot hang the upload indefinitely.
+     *
+     * @internal
+     */
+    _externalFetch(url: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Low-level request method. Resource classes wrap this with typed
+     * camelCase signatures; advanced users can call it directly for
+     * endpoints not yet covered by a resource.
      */
-    request<T>(method: string, path: string, body?: unknown, query?: Record<string, string>): Promise<T>;
+    request<T>(method: HttpMethod, path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+    private dispatch;
+    private buildUrl;
+    private buildHeaders;
+    private warnIfDeprecated;
+    private connectionErrorMessage;
 }
-/**
- * Create a new iSnap SDK client.
- *
- * @param config - API key and optional settings
- * @returns A configured {@link iSnapClient} instance
- *
- * @example
- * ```ts
- * import { init } from '@isnap/sdk';
- *
- * const client = init({
- *   apiKey: 'isnap_your_key',
- *   maxRetries: 5,
- *   retryDelayMs: 2000,
- * });
- * ```
- */
-export declare function init(config: iSnapConfig): iSnapClient;
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAS;IAE7B,+DAA+D;IACxD,QAAQ,EAAE,gBAAgB,CAAC;IAClC,qCAAqC;IAC9B,KAAK,EAAE,aAAa,CAAC;IAC5B,mCAAmC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;gBAEtB,MAAM,EAAE,WAAW;IAW/B;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAsD3G;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAErD"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAElB,MAAM,aAAa,CAAA;AAQpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAoB,MAAM,YAAY,CAAA;AAqB9E;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAA;IACzC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;gBAEvB,MAAM,EAAE,YAAY;IAYhC;;;;;;;;;;;;;;;OAeG;IACG,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAoB5E;;;;OAIG;IACG,OAAO,CAAC,CAAC,EACb,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,CAAC,CAAC;YAwBC,QAAQ;IA8GtB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,gBAAgB;IAsBxB,OAAO,CAAC,sBAAsB;CAO/B"}