ts-procedures 5.5.0 → 5.6.0-beta.0

package/README.md

@@ -880,6 +880,156 @@ import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode, APICon
 // Hono API (REST-style)
 import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
 import type { APIConfig, APIHttpRouteDoc, APIInput, HttpMethod, QueryParser } from 'ts-procedures/hono-api'
+
+// Client Runtime
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import type { ClientAdapter, ClientHooks, TypedStream, ClientInstance } from 'ts-procedures/client'
+
+// Code Generation
+import { generateClient } from 'ts-procedures/codegen'
+```
+
+## Client Code Generation
+
+ts-procedures can generate type-safe client SDKs directly from your server's `DocRegistry` output. Generated files include TypeScript types and callable functions for every registered procedure, organized by scope — no manual type duplication required.
+
+### Quick Start
+
+**Step 1 — Serve your docs endpoint:**
+
+```typescript
+app.get('/docs', (c) => c.json(docs.toJSON()))
+```
+
+**Step 2 — Generate the client:**
+
+```bash
+npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated/api
+```
+
+**Step 3 — Use the client:**
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({
+  adapter: createFetchAdapter(),
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) {
+      ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
+      return ctx
+    },
+  },
+})
+
+// Fully typed — params and response inferred from server schemas
+const user = await client.users.GetUser({ pathParams: { id: '123' } })
+```
+
+### Generated File Structure
+
+Running the codegen command produces one file per scope, plus shared error types and a barrel export:
+
+```
+generated/
+  users.ts           # Types + callables for "users" scope
+  billing.ts         # Types + callables for "billing" scope
+  notifications.ts   # Types + callables for stream procedures
+  _errors.ts         # Typed error classes + ProcedureErrorUnion
+  index.ts           # Barrel exports + createScopeBindings
+```
+
+### CLI Reference
+
+| Flag | Description | Required |
+|------|-------------|----------|
+| `--url <url>` | Fetch DocEnvelope from URL | One of `--url` or `--file` |
+| `--file <path>` | Read DocEnvelope from JSON file | One of `--url` or `--file` |
+| `--out <dir>` | Output directory | Yes |
+| `--watch` | Poll for changes and regenerate | No |
+| `--interval <ms>` | Watch poll interval (default: 3000) | No |
+| `--dry-run` | Preview without writing files | No |
+| `--client-import-path <path>` | Override import path (default: `ts-procedures/client`) | No |
+| `--enum-style <union\|enum>` | TypeScript enum style | No |
+| `--depluralize` | Singularize array item type names | No |
+
+### Adapter Interface
+
+The client requires an adapter that handles the actual HTTP transport. A built-in fetch adapter is included, and you can implement your own for any HTTP library:
+
+```typescript
+import { createFetchAdapter } from 'ts-procedures/client'
+
+// Use the built-in fetch adapter
+const adapter = createFetchAdapter({ headers: { 'X-API-Key': 'my-key' } })
+
+// Or implement your own (e.g., for axios)
+const axiosAdapter: ClientAdapter = {
+  async request({ url, method, headers, body }) {
+    const res = await axios({ url, method, headers, data: body })
+    return { status: res.status, headers: res.headers, body: res.data }
+  },
+  async stream({ url, method, headers, body }) {
+    // Return AsyncIterable of SSE events
+  },
+}
+```
+
+### Hooks
+
+Hooks let you intercept requests and responses globally or per-procedure call. Global hooks apply to every call made through the client instance; per-procedure hooks override or extend them for a single invocation.
+
+```typescript
+// Global hooks (apply to all calls)
+const client = createClient({
+  adapter,
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) { /* add auth headers */ return ctx },
+    onAfterResponse(ctx) { /* handle errors, logging */ },
+    onError(ctx) { /* error reporting */ },
+  },
+})
+
+// Per-procedure hook override
+await client.users.GetUser({ pathParams: { id: '123' } }, {
+  onAfterResponse(ctx) {
+    const rateLimit = ctx.response.headers['x-rate-limit-remaining']
+  },
+})
+```
+
+### Streaming
+
+Stream procedures return a `TypedStream` — an async iterable for yield values, with a `.result` promise for the final return value:
+
+```typescript
+const stream = client.events.WatchNotifications({ filter: 'all' })
+
+for await (const event of stream) {
+  console.log(event) // typed as WatchNotificationsYield
+}
+
+const result = await stream.result // typed as WatchNotificationsReturn
+```
+
+### Programmatic API
+
+For build pipelines or custom tooling, `generateClient` can be called directly without the CLI:
+
+```typescript
+import { generateClient } from 'ts-procedures/codegen'
+
+await generateClient({
+  url: 'http://localhost:3000/docs',
+  outDir: './src/generated/api',
+  clientImportPath: '@my-app/procedures-client', // optional
+  dryRun: false, // optional
+})
 ```
 
 ## AI Agent Setup

package/agent_config/claude-code/skills/guide/api-reference.md

@@ -751,6 +751,183 @@ type AnyHttpRouteDoc = RPCHttpRouteDoc | APIHttpRouteDoc | StreamHttpRouteDoc
 
 ---
 
+## createClient(config)
+
+Creates a typed client instance bound to generated scope bindings.
+
+```typescript
+function createClient<TScopes>(config: {
+  adapter: ClientAdapter
+  basePath: string
+  scopes: (client: ClientInstance) => TScopes
+  hooks?: ClientHooks
+}): TScopes
+```
+
+### Parameters
+
+- `config.adapter` — Transport adapter implementing `ClientAdapter`. Use `createFetchAdapter()` for fetch-based transport.
+- `config.basePath` — Base URL prepended to all request paths (e.g., `'http://localhost:3000'`).
+- `config.scopes` — Factory function that receives a raw `ClientInstance` and returns the typed scope object. Typically the `createScopeBindings` export from generated code.
+- `config.hooks` — Optional global hooks applied to every call. Can be overridden per call.
+
+### Return Value
+
+Returns the result of `config.scopes(clientInstance)` — a typed object where each key is a scope and each value is a record of callable procedure functions.
+
+### ClientHooks
+
+```typescript
+interface ClientHooks {
+  onBeforeRequest?: (ctx: { request: ClientRequest }) => { request: ClientRequest } | void
+  onAfterResponse?: (ctx: { request: ClientRequest; response: ClientResponse }) => void
+}
+```
+
+### Example
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({
+  adapter: createFetchAdapter(),
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) {
+      ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
+      return ctx
+    },
+  },
+})
+
+const user = await client.users.GetUser({ pathParams: { id: '123' } })
+```
+
+---
+
+## createFetchAdapter()
+
+Creates a `ClientAdapter` using the global `fetch` API.
+
+```typescript
+function createFetchAdapter(options?: {
+  fetch?: typeof globalThis.fetch
+}): ClientAdapter
+```
+
+### Parameters
+
+- `options.fetch` — Optional custom fetch implementation. Defaults to `globalThis.fetch`.
+
+### Return Value
+
+A `ClientAdapter` that supports both request/response and SSE streaming.
+
+### Example
+
+```typescript
+import { createFetchAdapter } from 'ts-procedures/client'
+
+// Default (uses globalThis.fetch)
+const adapter = createFetchAdapter()
+
+// Custom fetch (e.g., node-fetch, undici)
+const adapter = createFetchAdapter({ fetch: customFetch })
+```
+
+---
+
+## generateClient(options)
+
+Build-time CLI and programmatic API for generating typed client files from a `DocEnvelope`.
+
+```typescript
+// CLI usage (preferred)
+// npx ts-procedures-codegen --url <url> --out <dir> [--fetch]
+
+// Programmatic
+async function generateClient(options: {
+  envelope: DocEnvelope
+  outDir: string
+}): Promise<void>
+```
+
+### CLI Options
+
+| Flag | Description |
+|------|-------------|
+| `--url <url>` | URL to fetch the `DocEnvelope` JSON from (e.g., `http://localhost:3000/docs`) |
+| `--out <dir>` | Output directory for generated files |
+| `--fetch` | Fetch the envelope at runtime rather than from a local file |
+
+### Generated Output
+
+- One `.ts` file per scope (e.g., `users.ts`, `events.ts`)
+- A root `index.ts` exporting `createScopeBindings`
+- Each scope file exports fully-typed callable functions and TypeScript types
+
+### Example
+
+```typescript
+// CLI
+// npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated/api
+
+// Programmatic
+import { generateClient } from 'ts-procedures/codegen'
+
+await generateClient({
+  envelope: await fetch('http://localhost:3000/docs').then(r => r.json()),
+  outDir: './src/generated/api',
+})
+```
+
+---
+
+## TypedStream\<TYield, TReturn\>
+
+Async iterable returned by stream procedure calls on the generated client. Yields typed values and exposes a `result` promise for the stream's final return value.
+
+```typescript
+interface TypedStream<TYield, TReturn> extends AsyncIterable<TYield> {
+  result: Promise<TReturn>
+  [Symbol.asyncIterator](): AsyncIterator<TYield>
+}
+```
+
+### Type Parameters
+
+- `TYield` — Type of each yielded value (from `schema.yieldType`)
+- `TReturn` — Type of the stream's return value (from `schema.returnType`). Sent as `event: 'return'` SSE message by `HonoStreamAppBuilder`.
+
+### Key Behavior
+
+- Iterating with `for await...of` yields each SSE data event as `TYield`
+- `stream.result` resolves when the stream closes with the final return value
+- If the stream has no return value, `TReturn` is `void` and `result` resolves to `undefined`
+
+### Example
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({ adapter: createFetchAdapter(), basePath: '...', scopes: createScopeBindings })
+
+const stream = client.events.WatchNotifications({ filter: 'all' })
+
+// Consume yielded values
+for await (const event of stream) {
+  console.log(event) // Typed as WatchNotificationsYield
+}
+
+// Access return value after iteration completes
+const summary = await stream.result // Typed as WatchNotificationsReturn
+```
+
+---
+
 ## Stack Utilities
 
 ### captureDefinitionInfo()

package/agent_config/claude-code/skills/guide/patterns.md

@@ -758,3 +758,110 @@ onRequestStart → factoryContext() → params validation
                                   → onStreamStart → handler yields → onStreamEnd → onRequestEnd
                                                   → onMidStreamError (if throw) → onStreamEnd → onRequestEnd
 ```
+
+---
+
+## Client Code Generation Setup
+
+```typescript
+import { DocRegistry } from 'ts-procedures/http-docs'
+
+// Server: serve docs endpoint
+const docs = new DocRegistry({
+  basePath: '/api',
+  headers: [{ name: 'Authorization', description: 'Bearer token' }],
+  errors: DocRegistry.defaultErrors(),
+})
+  .from(rpcBuilder)
+  .from(apiBuilder)
+  .from(streamBuilder)
+
+app.get('/docs', (c) => c.json(docs.toJSON()))
+
+// Then generate client:
+// npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated/api
+```
+
+---
+
+## Type-Safe Client Usage
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({
+  adapter: createFetchAdapter(),
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) {
+      ctx.request.headers = {
+        ...ctx.request.headers,
+        Authorization: `Bearer ${getToken()}`,
+      }
+      return ctx
+    },
+    onAfterResponse(ctx) {
+      if (ctx.response.status === 401) {
+        redirect('/login')
+      }
+    },
+  },
+})
+
+// Fully typed — params and response inferred from server schemas
+const user = await client.users.GetUser({ pathParams: { id: '123' } })
+```
+
+---
+
+## Streaming Client Usage
+
+```typescript
+const stream = client.events.WatchNotifications({ filter: 'all' })
+
+for await (const event of stream) {
+  console.log(event) // Typed as WatchNotificationsYield
+}
+
+// Access the stream's return value
+const result = await stream.result // Typed as WatchNotificationsReturn
+```
+
+---
+
+## Per-Procedure Hook Override
+
+```typescript
+// Override hooks for a specific call
+await client.users.GetUser({ pathParams: { id: '123' } }, {
+  onAfterResponse(ctx) {
+    const rateLimit = ctx.response.headers['x-rate-limit-remaining']
+    console.log(`Rate limit remaining: ${rateLimit}`)
+  },
+})
+```
+
+---
+
+## Custom Client Adapter (Axios)
+
+```typescript
+import type { ClientAdapter } from 'ts-procedures/client'
+import axios from 'axios'
+
+const axiosAdapter: ClientAdapter = {
+  async request({ url, method, headers, body, signal }) {
+    const res = await axios({ url, method, headers, data: body, signal })
+    return {
+      status: res.status,
+      headers: Object.fromEntries(Object.entries(res.headers).filter(([, v]) => typeof v === 'string')) as Record<string, string>,
+      body: res.data,
+    }
+  },
+  async stream() {
+    throw new Error('Streaming not supported with axios adapter')
+  },
+}
+```

package/agent_config/copilot/copilot-instructions.md

@@ -292,3 +292,83 @@ describe('GetUser', () => {
 - `scope` can be string or string[] (joined as path segments)
 - Procedure name auto-converted to kebab-case
 - Stream routes support both GET (query params) and POST (JSON body)
+
+## Client Code Generation
+
+Generate type-safe client SDKs from a running DocRegistry endpoint.
+
+### Imports
+
+```typescript
+// Client Runtime
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import type { ClientAdapter, ClientHooks, TypedStream, ClientInstance } from 'ts-procedures/client'
+
+// Code Generation (build-time only)
+import { generateClient } from 'ts-procedures/codegen'
+```
+
+### CLI
+
+```bash
+npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated/api
+```
+
+Generates one `.ts` file per scope plus a root `index.ts` exporting `createScopeBindings`.
+
+### createClient Example
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({
+  adapter: createFetchAdapter(),
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) {
+      ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
+      return ctx
+    },
+    onAfterResponse(ctx) {
+      if (ctx.response.status === 401) redirect('/login')
+    },
+  },
+})
+
+// Fully typed — params and response inferred from server schemas
+const user = await client.users.GetUser({ pathParams: { id: '123' } })
+
+// Per-call hook override
+await client.users.GetUser({ pathParams: { id: '123' } }, {
+  onAfterResponse(ctx) {
+    console.log(ctx.response.headers['x-rate-limit-remaining'])
+  },
+})
+```
+
+### Hook Types
+
+```typescript
+interface ClientHooks {
+  onBeforeRequest?: (ctx: { request: ClientRequest }) => { request: ClientRequest } | void
+  onAfterResponse?: (ctx: { request: ClientRequest; response: ClientResponse }) => void
+}
+```
+
+### TypedStream Usage
+
+```typescript
+const stream = client.events.WatchNotifications({ filter: 'all' })
+
+for await (const event of stream) {
+  console.log(event) // Typed as WatchNotificationsYield
+}
+
+const result = await stream.result // Typed as WatchNotificationsReturn
+```
+
+- `TypedStream<TYield, TReturn>` extends `AsyncIterable<TYield>`
+- `stream.result` resolves with the final return value sent as `event: 'return'` SSE message
+- Stream procedures that return `void` have `result` resolve to `undefined`

package/agent_config/cursor/cursorrules

@@ -292,3 +292,83 @@ describe('GetUser', () => {
 - `scope` can be string or string[] (joined as path segments)
 - Procedure name auto-converted to kebab-case
 - Stream routes support both GET (query params) and POST (JSON body)
+
+## Client Code Generation
+
+Generate type-safe client SDKs from a running DocRegistry endpoint.
+
+### Imports
+
+```typescript
+// Client Runtime
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import type { ClientAdapter, ClientHooks, TypedStream, ClientInstance } from 'ts-procedures/client'
+
+// Code Generation (build-time only)
+import { generateClient } from 'ts-procedures/codegen'
+```
+
+### CLI
+
+```bash
+npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated/api
+```
+
+Generates one `.ts` file per scope plus a root `index.ts` exporting `createScopeBindings`.
+
+### createClient Example
+
+```typescript
+import { createClient, createFetchAdapter } from 'ts-procedures/client'
+import { createScopeBindings } from './generated/api'
+
+const client = createClient({
+  adapter: createFetchAdapter(),
+  basePath: 'http://localhost:3000',
+  scopes: createScopeBindings,
+  hooks: {
+    onBeforeRequest(ctx) {
+      ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
+      return ctx
+    },
+    onAfterResponse(ctx) {
+      if (ctx.response.status === 401) redirect('/login')
+    },
+  },
+})
+
+// Fully typed — params and response inferred from server schemas
+const user = await client.users.GetUser({ pathParams: { id: '123' } })
+
+// Per-call hook override
+await client.users.GetUser({ pathParams: { id: '123' } }, {
+  onAfterResponse(ctx) {
+    console.log(ctx.response.headers['x-rate-limit-remaining'])
+  },
+})
+```
+
+### Hook Types
+
+```typescript
+interface ClientHooks {
+  onBeforeRequest?: (ctx: { request: ClientRequest }) => { request: ClientRequest } | void
+  onAfterResponse?: (ctx: { request: ClientRequest; response: ClientResponse }) => void
+}
+```
+
+### TypedStream Usage
+
+```typescript
+const stream = client.events.WatchNotifications({ filter: 'all' })
+
+for await (const event of stream) {
+  console.log(event) // Typed as WatchNotificationsYield
+}
+
+const result = await stream.result // Typed as WatchNotificationsReturn
+```
+
+- `TypedStream<TYield, TReturn>` extends `AsyncIterable<TYield>`
+- `stream.result` resolves with the final return value sent as `event: 'return'` SSE message
+- Stream procedures that return `void` have `result` resolve to `undefined`

package/build/client/call.d.ts

@@ -0,0 +1,14 @@
+import type { ClientAdapter, ClientHooks, CallDescriptor } from './types.js';
+/**
+ * Executes a single procedure call through the adapter.
+ *
+ * Flow:
+ * 1. Build AdapterRequest from descriptor
+ * 2. Run onBeforeRequest hooks (global then local)
+ * 3. Call adapter.request()
+ * 4. On adapter error: run onError hooks, re-throw
+ * 5. Run onAfterResponse hooks (hooks may mutate response.status)
+ * 6. If response status is non-2xx: throw ClientRequestError
+ * 7. Return response.body as TResponse
+ */
+export declare function executeCall<TResponse>(descriptor: CallDescriptor, basePath: string, adapter: ClientAdapter, globalHooks: ClientHooks, localHooks: ClientHooks | undefined): Promise<TResponse>;

package/build/client/call.js

@@ -0,0 +1,47 @@
+import { buildAdapterRequest } from './request-builder.js';
+import { runBeforeRequest, runAfterResponse, runOnError } from './hooks.js';
+import { ClientRequestError } from './errors.js';
+/**
+ * Executes a single procedure call through the adapter.
+ *
+ * Flow:
+ * 1. Build AdapterRequest from descriptor
+ * 2. Run onBeforeRequest hooks (global then local)
+ * 3. Call adapter.request()
+ * 4. On adapter error: run onError hooks, re-throw
+ * 5. Run onAfterResponse hooks (hooks may mutate response.status)
+ * 6. If response status is non-2xx: throw ClientRequestError
+ * 7. Return response.body as TResponse
+ */
+export async function executeCall(descriptor, basePath, adapter, globalHooks, localHooks) {
+    // 1. Build the initial request
+    let request = buildAdapterRequest(descriptor, basePath);
+    // 2. Run before-request hooks — they may mutate the request
+    const beforeCtx = await runBeforeRequest({ procedureName: descriptor.name, scope: descriptor.scope, request }, globalHooks, localHooks);
+    request = beforeCtx.request;
+    // 3. Call the adapter
+    let response;
+    try {
+        response = await adapter.request(request);
+    }
+    catch (err) {
+        // 4. On adapter error: run error hooks, re-throw
+        await runOnError({ procedureName: descriptor.name, scope: descriptor.scope, request, error: err }, globalHooks, localHooks);
+        throw err;
+    }
+    // 5. Run after-response hooks — they may mutate response.status to swallow errors
+    await runAfterResponse({ procedureName: descriptor.name, scope: descriptor.scope, request, response }, globalHooks, localHooks);
+    // 6. Check status AFTER hooks (hooks may have swallowed the error by mutating status)
+    if (response.status < 200 || response.status >= 300) {
+        throw new ClientRequestError({
+            status: response.status,
+            headers: response.headers,
+            body: response.body,
+            procedureName: descriptor.name,
+            scope: descriptor.scope,
+        });
+    }
+    // 7. Return the body
+    return response.body;
+}
+//# sourceMappingURL=call.js.map

package/build/client/call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.js","sourceRoot":"","sources":["../../src/client/call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAOhD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,UAA0B,EAC1B,QAAgB,EAChB,OAAsB,EACtB,WAAwB,EACxB,UAAmC;IAEnC,+BAA+B;IAC/B,IAAI,OAAO,GAAG,mBAAmB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;IAEvD,4DAA4D;IAC5D,MAAM,SAAS,GAAG,MAAM,gBAAgB,CACtC,EAAE,aAAa,EAAE,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,EACpE,WAAW,EACX,UAAU,CACX,CAAA;IACD,OAAO,GAAG,SAAS,CAAC,OAAO,CAAA;IAE3B,sBAAsB;IACtB,IAAI,QAAQ,CAAA;IACZ,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,iDAAiD;QACjD,MAAM,UAAU,CACd,EAAE,aAAa,EAAE,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAChF,WAAW,EACX,UAAU,CACX,CAAA;QACD,MAAM,GAAG,CAAA;IACX,CAAC;IAED,kFAAkF;IAClF,MAAM,gBAAgB,CACpB,EAAE,aAAa,EAAE,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,EAC9E,WAAW,EACX,UAAU,CACX,CAAA;IAED,sFAAsF;IACtF,IAAI,QAAQ,CAAC,MAAM,GAAG,GAAG,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;QACpD,MAAM,IAAI,kBAAkB,CAAC;YAC3B,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,aAAa,EAAE,UAAU,CAAC,IAAI;YAC9B,KAAK,EAAE,UAAU,CAAC,KAAK;SACxB,CAAC,CAAA;IACJ,CAAC;IAED,qBAAqB;IACrB,OAAO,QAAQ,CAAC,IAAiB,CAAA;AACnC,CAAC"}

package/build/client/call.test.d.ts

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