@zavudev/sdk 0.0.16 → 0.3.0

package/README.md

@@ -1,486 +1,361 @@
-# @zavudev/sdk
+# Zavudev TypeScript API Library
 
-Developer-friendly & type-safe Typescript SDK specifically catered to leverage *@zavudev/sdk* API.
+[![NPM version](<https://img.shields.io/npm/v/@zavudev/sdk.svg?label=npm%20(stable)>)](https://npmjs.org/package/@zavudev/sdk) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@zavudev/sdk)
 
-[![License: MIT](https://img.shields.io/badge/LICENSE_//_MIT-3b5bdb?style=for-the-badge&labelColor=eff6ff)](https://opensource.org/licenses/MIT)
+This library provides convenient access to the Zavudev REST API from server-side TypeScript or JavaScript.
 
+The full API of this library can be found in [api.md](api.md).
 
+It is generated with [Stainless](https://www.stainless.com/).
 
-<!-- Start Summary [summary] -->
-## Summary
+## Installation
 
-Zavu Messaging API: Unified multi-channel messaging API for Zavu.
+```sh
+npm install @zavudev/sdk
+```
 
-Supported channels:
-- **SMS**: Simple text messages
-- **WhatsApp**: Rich messaging with media, buttons, lists, and templates
+## Usage
 
-Design goals:
-- Simple `send()` entrypoint for developers
-- Project-level authentication via Bearer token
-- Support for all WhatsApp message types (text, image, video, audio, document, sticker, location, contact, buttons, list, reaction, template)
-- If a non-text message type is sent, WhatsApp channel is used automatically
-- 24-hour WhatsApp conversation window enforcement
-<!-- End Summary [summary] -->
+The full API of this library can be found in [api.md](api.md).
 
-<!-- Start Table of Contents [toc] -->
-## Table of Contents
-<!-- $toc-max-depth=2 -->
-* [@zavudev/sdk](#zavudevsdk)
-  * [SDK Installation](#sdk-installation)
-  * [Requirements](#requirements)
-  * [SDK Example Usage](#sdk-example-usage)
-  * [Authentication](#authentication)
-  * [Available Resources and Operations](#available-resources-and-operations)
-  * [Standalone functions](#standalone-functions)
-  * [Retries](#retries)
-  * [Error Handling](#error-handling)
-  * [Server Selection](#server-selection)
-  * [Custom HTTP Client](#custom-http-client)
-  * [Debugging](#debugging)
-* [Development](#development)
-  * [Maturity](#maturity)
-  * [Contributions](#contributions)
+<!-- prettier-ignore -->
+```js
+import Zavudev from '@zavudev/sdk';
 
-<!-- End Table of Contents [toc] -->
+const client = new Zavudev({
+  apiKey: process.env['ZAVUDEV_API_KEY'], // This is the default and can be omitted
+});
 
-<!-- Start SDK Installation [installation] -->
-## SDK Installation
+const messageResponse = await client.messages.send({ to: '+56912345678' });
 
+console.log(messageResponse.message);
+```
 
+### Request & Response types
 
-The SDK can be installed with either [npm](https://www.npmjs.com/), [pnpm](https://pnpm.io/), [bun](https://bun.sh/) or [yarn](https://classic.yarnpkg.com/en/) package managers.
+This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
 
-### NPM
+<!-- prettier-ignore -->
+```ts
+import Zavudev from '@zavudev/sdk';
 
-```bash
-npm add @zavudev/sdk
-```
-
-### PNPM
+const client = new Zavudev({
+  apiKey: process.env['ZAVUDEV_API_KEY'], // This is the default and can be omitted
+});
 
-```bash
-pnpm add @zavudev/sdk
+const params: Zavudev.MessageSendParams = { to: '+56912345678' };
+const messageResponse: Zavudev.MessageResponse = await client.messages.send(params);
 ```
 
-### Bun
+Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
 
-```bash
-bun add @zavudev/sdk
-```
+## Handling errors
 
-### Yarn
+When the library is unable to connect to the API,
+or if the API returns a non-success status code (i.e., 4xx or 5xx response),
+a subclass of `APIError` will be thrown:
 
-```bash
-yarn add @zavudev/sdk
+<!-- prettier-ignore -->
+```ts
+const messageResponse = await client.messages.send({ to: '+56912345678' }).catch(async (err) => {
+  if (err instanceof Zavudev.APIError) {
+    console.log(err.status); // 400
+    console.log(err.name); // BadRequestError
+    console.log(err.headers); // {server: 'nginx', ...}
+  } else {
+    throw err;
+  }
+});
 ```
 
-> [!NOTE]
-> This package is published with CommonJS and ES Modules (ESM) support.
-<!-- End SDK Installation [installation] -->
+Error codes are as follows:
 
-<!-- Start Requirements [requirements] -->
-## Requirements
+| Status Code | Error Type                 |
+| ----------- | -------------------------- |
+| 400         | `BadRequestError`          |
+| 401         | `AuthenticationError`      |
+| 403         | `PermissionDeniedError`    |
+| 404         | `NotFoundError`            |
+| 422         | `UnprocessableEntityError` |
+| 429         | `RateLimitError`           |
+| >=500       | `InternalServerError`      |
+| N/A         | `APIConnectionError`       |
 
-For supported JavaScript runtimes, please consult [RUNTIMES.md](RUNTIMES.md).
-<!-- End Requirements [requirements] -->
+### Retries
 
-<!-- Start SDK Example Usage [usage] -->
-## SDK Example Usage
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
+429 Rate Limit, and >=500 Internal errors will all be retried by default.
 
-### Example
+You can use the `maxRetries` option to configure or disable this:
 
-```typescript
-import { Zavu } from "@zavudev/sdk";
+<!-- prettier-ignore -->
+```js
+// Configure the default for all requests:
+const client = new Zavudev({
+  maxRetries: 0, // default is 2
+});
 
-const zavu = new Zavu({
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
+// Or, configure per-request:
+await client.messages.send({ to: '+56912345678' }, {
+  maxRetries: 5,
 });
+```
 
-async function run() {
-  const result = await zavu.sendMessage({
-    zavuSender: "sender_12345",
-    body: {
-      to: "+56912345678",
-      text: "Your verification code is 123456",
-    },
-  });
+### Timeouts
 
-  console.log(result);
-}
+Requests time out after 1 minute by default. You can configure this with a `timeout` option:
 
-run();
+<!-- prettier-ignore -->
+```ts
+// Configure the default for all requests:
+const client = new Zavudev({
+  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
+});
 
+// Override per-request:
+await client.messages.send({ to: '+56912345678' }, {
+  timeout: 5 * 1000,
+});
 ```
-<!-- End SDK Example Usage [usage] -->
-
-<!-- Start Authentication [security] -->
-## Authentication
 
-### Per-Client Security Schemes
+On timeout, an `APIConnectionTimeoutError` is thrown.
 
-This SDK supports the following security scheme globally:
+Note that requests which time out will be [retried twice by default](#retries).
 
-| Name         | Type | Scheme      |
-| ------------ | ---- | ----------- |
-| `bearerAuth` | http | HTTP Bearer |
+## Advanced Usage
 
-To authenticate with the API the `bearerAuth` parameter must be set when initializing the SDK client instance. For example:
-```typescript
-import { Zavu } from "@zavudev/sdk";
+### Accessing raw Response data (e.g., headers)
 
-const zavu = new Zavu({
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
-});
+The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
+This method returns as soon as the headers for a successful response are received and does not consume the response body, so you are free to write custom parsing or streaming logic.
 
-async function run() {
-  const result = await zavu.sendMessage({
-    zavuSender: "sender_12345",
-    body: {
-      to: "+56912345678",
-      text: "Your verification code is 123456",
-    },
-  });
+You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
+Unlike `.asResponse()` this method consumes the body, returning once it is parsed.
 
-  console.log(result);
-}
+<!-- prettier-ignore -->
+```ts
+const client = new Zavudev();
 
-run();
+const response = await client.messages.send({ to: '+56912345678' }).asResponse();
+console.log(response.headers.get('X-My-Header'));
+console.log(response.statusText); // access the underlying Response object
 
+const { data: messageResponse, response: raw } = await client.messages
+  .send({ to: '+56912345678' })
+  .withResponse();
+console.log(raw.headers.get('X-My-Header'));
+console.log(messageResponse.message);
 ```
-<!-- End Authentication [security] -->
-
-<!-- Start Available Resources and Operations [operations] -->
-## Available Resources and Operations
-
-<details open>
-<summary>Available methods</summary>
-
-### [Zavu SDK](docs/sdks/zavu/README.md)
-
-* [sendMessage](docs/sdks/zavu/README.md#sendmessage) - Send a message
-* [listMessages](docs/sdks/zavu/README.md#listmessages) - List messages
-* [getMessage](docs/sdks/zavu/README.md#getmessage) - Get message by ID
-* [sendReaction](docs/sdks/zavu/README.md#sendreaction) - Send reaction to message
-* [listTemplates](docs/sdks/zavu/README.md#listtemplates) - List templates
-* [createTemplate](docs/sdks/zavu/README.md#createtemplate) - Create template
-* [getTemplate](docs/sdks/zavu/README.md#gettemplate) - Get template
-* [deleteTemplate](docs/sdks/zavu/README.md#deletetemplate) - Delete template
-* [listSenders](docs/sdks/zavu/README.md#listsenders) - List senders
-* [createSender](docs/sdks/zavu/README.md#createsender) - Create sender
-* [getSender](docs/sdks/zavu/README.md#getsender) - Get sender
-* [updateSender](docs/sdks/zavu/README.md#updatesender) - Update sender
-* [deleteSender](docs/sdks/zavu/README.md#deletesender) - Delete sender
-* [listContacts](docs/sdks/zavu/README.md#listcontacts) - List contacts
-* [getContact](docs/sdks/zavu/README.md#getcontact) - Get contact
-* [updateContact](docs/sdks/zavu/README.md#updatecontact) - Update contact
-* [getContactByPhone](docs/sdks/zavu/README.md#getcontactbyphone) - Get contact by phone number
-* [introspectPhone](docs/sdks/zavu/README.md#introspectphone) - Introspect phone number
-
-</details>
-<!-- End Available Resources and Operations [operations] -->
-
-<!-- Start Standalone functions [standalone-funcs] -->
-## Standalone functions
-
-All the methods listed above are available as standalone functions. These
-functions are ideal for use in applications running in the browser, serverless
-runtimes or other environments where application bundle size is a primary
-concern. When using a bundler to build your application, all unused
-functionality will be either excluded from the final bundle or tree-shaken away.
-
-To read more about standalone functions, check [FUNCTIONS.md](./FUNCTIONS.md).
-
-<details>
-
-<summary>Available standalone functions</summary>
-
-- [`createSender`](docs/sdks/zavu/README.md#createsender) - Create sender
-- [`createTemplate`](docs/sdks/zavu/README.md#createtemplate) - Create template
-- [`deleteSender`](docs/sdks/zavu/README.md#deletesender) - Delete sender
-- [`deleteTemplate`](docs/sdks/zavu/README.md#deletetemplate) - Delete template
-- [`getContact`](docs/sdks/zavu/README.md#getcontact) - Get contact
-- [`getContactByPhone`](docs/sdks/zavu/README.md#getcontactbyphone) - Get contact by phone number
-- [`getMessage`](docs/sdks/zavu/README.md#getmessage) - Get message by ID
-- [`getSender`](docs/sdks/zavu/README.md#getsender) - Get sender
-- [`getTemplate`](docs/sdks/zavu/README.md#gettemplate) - Get template
-- [`introspectPhone`](docs/sdks/zavu/README.md#introspectphone) - Introspect phone number
-- [`listContacts`](docs/sdks/zavu/README.md#listcontacts) - List contacts
-- [`listMessages`](docs/sdks/zavu/README.md#listmessages) - List messages
-- [`listSenders`](docs/sdks/zavu/README.md#listsenders) - List senders
-- [`listTemplates`](docs/sdks/zavu/README.md#listtemplates) - List templates
-- [`sendMessage`](docs/sdks/zavu/README.md#sendmessage) - Send a message
-- [`sendReaction`](docs/sdks/zavu/README.md#sendreaction) - Send reaction to message
-- [`updateContact`](docs/sdks/zavu/README.md#updatecontact) - Update contact
-- [`updateSender`](docs/sdks/zavu/README.md#updatesender) - Update sender
-
-</details>
-<!-- End Standalone functions [standalone-funcs] -->
-
-<!-- Start Retries [retries] -->
-## Retries
-
-Some of the endpoints in this SDK support retries.  If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API.  However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.
-
-To change the default retry strategy for a single API call, simply provide a retryConfig object to the call:
-```typescript
-import { Zavu } from "@zavudev/sdk";
-
-const zavu = new Zavu({
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
-});
 
-async function run() {
-  const result = await zavu.sendMessage({
-    zavuSender: "sender_12345",
-    body: {
-      to: "+56912345678",
-      text: "Your verification code is 123456",
-    },
-  }, {
-    retries: {
-      strategy: "backoff",
-      backoff: {
-        initialInterval: 1,
-        maxInterval: 50,
-        exponent: 1.1,
-        maxElapsedTime: 100,
-      },
-      retryConnectionErrors: false,
-    },
-  });
-
-  console.log(result);
-}
-
-run();
+### Logging
 
-```
+> [!IMPORTANT]
+> All log messages are intended for debugging only. The format and content of log messages
+> may change between releases.
 
-If you'd like to override the default retry strategy for all operations that support retries, you can provide a retryConfig at SDK initialization:
-```typescript
-import { Zavu } from "@zavudev/sdk";
-
-const zavu = new Zavu({
-  retryConfig: {
-    strategy: "backoff",
-    backoff: {
-      initialInterval: 1,
-      maxInterval: 50,
-      exponent: 1.1,
-      maxElapsedTime: 100,
-    },
-    retryConnectionErrors: false,
-  },
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
-});
+#### Log levels
 
-async function run() {
-  const result = await zavu.sendMessage({
-    zavuSender: "sender_12345",
-    body: {
-      to: "+56912345678",
-      text: "Your verification code is 123456",
-    },
-  });
+The log level can be configured in two ways:
 
-  console.log(result);
-}
+1. Via the `ZAVUDEV_LOG` environment variable
+2. Using the `logLevel` client option (overrides the environment variable if set)
 
-run();
+```ts
+import Zavudev from '@zavudev/sdk';
 
+const client = new Zavudev({
+  logLevel: 'debug', // Show all log messages
+});
 ```
-<!-- End Retries [retries] -->
 
-<!-- Start Error Handling [errors] -->
-## Error Handling
+Available log levels, from most to least verbose:
 
-[`SDKError`](./src/models/errors/sdkerror.ts) is the base class for all HTTP error responses. It has the following properties:
+- `'debug'` - Show debug messages, info, warnings, and errors
+- `'info'` - Show info messages, warnings, and errors
+- `'warn'` - Show warnings and errors (default)
+- `'error'` - Show only errors
+- `'off'` - Disable all logging
 
-| Property            | Type       | Description                                                                             |
-| ------------------- | ---------- | --------------------------------------------------------------------------------------- |
-| `error.message`     | `string`   | Error message                                                                           |
-| `error.statusCode`  | `number`   | HTTP response status code eg `404`                                                      |
-| `error.headers`     | `Headers`  | HTTP response headers                                                                   |
-| `error.body`        | `string`   | HTTP body. Can be empty string if no body is returned.                                  |
-| `error.rawResponse` | `Response` | Raw HTTP response                                                                       |
-| `error.data$`       |            | Optional. Some errors may contain structured data. [See Error Classes](#error-classes). |
+At the `'debug'` level, all HTTP requests and responses are logged, including headers and bodies.
+Some authentication-related headers are redacted, but sensitive data in request and response bodies
+may still be visible.
 
-### Example
-```typescript
-import { Zavu } from "@zavudev/sdk";
-import * as errors from "@zavudev/sdk/models/errors";
+#### Custom logger
 
-const zavu = new Zavu({
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
-});
+By default, this library logs to `globalThis.console`. You can also provide a custom logger.
+Most logging libraries are supported, including [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale), and [@std/log](https://jsr.io/@std/log). If your logger doesn't work, please open an issue.
 
-async function run() {
-  try {
-    const result = await zavu.sendMessage({
-      zavuSender: "sender_12345",
-      body: {
-        to: "+56912345678",
-        text: "Your verification code is 123456",
-      },
-    });
-
-    console.log(result);
-  } catch (error) {
-    // The base class for HTTP error responses
-    if (error instanceof errors.SDKError) {
-      console.log(error.message);
-      console.log(error.statusCode);
-      console.log(error.body);
-      console.log(error.headers);
-
-      // Depending on the method different errors may be thrown
-      if (error instanceof errors.ErrorT) {
-        console.log(error.data$.code); // string
-        console.log(error.data$.message); // string
-        console.log(error.data$.details); // { [k: string]: any }
-      }
-    }
-  }
-}
+When providing a custom logger, the `logLevel` option still controls which messages are emitted, messages
+below the configured level will not be sent to your logger.
 
-run();
+```ts
+import Zavudev from '@zavudev/sdk';
+import pino from 'pino';
 
+const logger = pino();
+
+const client = new Zavudev({
+  logger: logger.child({ name: 'Zavudev' }),
+  logLevel: 'debug', // Send all messages to pino, allowing it to filter
+});
 ```
 
-### Error Classes
-**Primary errors:**
-* [`SDKError`](./src/models/errors/sdkerror.ts): The base class for HTTP error responses.
-  * [`ErrorT`](./src/models/errors/errort.ts): Generic error.
+### Making custom/undocumented requests
+
+This library is typed for convenient access to the documented API. If you need to access undocumented
+endpoints, params, or response properties, the library can still be used.
 
-<details><summary>Less common errors (6)</summary>
+#### Undocumented endpoints
 
-<br />
+To make requests to undocumented endpoints, you can use `client.get`, `client.post`, and other HTTP verbs.
+Options on the client, such as retries, will be respected when making these requests.
 
-**Network errors:**
-* [`ConnectionError`](./src/models/errors/httpclienterrors.ts): HTTP client was unable to make a request to a server.
-* [`RequestTimeoutError`](./src/models/errors/httpclienterrors.ts): HTTP request timed out due to an AbortSignal signal.
-* [`RequestAbortedError`](./src/models/errors/httpclienterrors.ts): HTTP request was aborted by the client.
-* [`InvalidRequestError`](./src/models/errors/httpclienterrors.ts): Any input used to create a request is invalid.
-* [`UnexpectedClientError`](./src/models/errors/httpclienterrors.ts): Unrecognised or unexpected error.
+```ts
+await client.post('/some/path', {
+  body: { some_prop: 'foo' },
+  query: { some_query_arg: 'bar' },
+});
+```
 
+#### Undocumented request params
 
-**Inherit from [`SDKError`](./src/models/errors/sdkerror.ts)**:
-* [`ResponseValidationError`](./src/models/errors/responsevalidationerror.ts): Type mismatch between the data returned from the server and the structure expected by the SDK. See `error.rawValue` for the raw value and `error.pretty()` for a nicely formatted multi-line string.
+To make requests using undocumented parameters, you may use `// @ts-expect-error` on the undocumented
+parameter. This library doesn't validate at runtime that the request matches the type, so any extra values you
+send will be sent as-is.
 
-</details>
-<!-- End Error Handling [errors] -->
+```ts
+client.messages.send({
+  // ...
+  // @ts-expect-error baz is not yet public
+  baz: 'undocumented option',
+});
+```
 
-<!-- Start Server Selection [server] -->
-## Server Selection
+For requests with the `GET` verb, any extra params will be in the query, all other requests will send the
+extra param in the body.
 
-### Override Server URL Per-Client
+If you want to explicitly send an extra argument, you can do so with the `query`, `body`, and `headers` request
+options.
 
-The default server can be overridden globally by passing a URL to the `serverURL: string` optional parameter when initializing the SDK client instance. For example:
-```typescript
-import { Zavu } from "@zavudev/sdk";
+#### Undocumented response properties
 
-const zavu = new Zavu({
-  serverURL: "https://api.zavu.dev",
-  bearerAuth: "<YOUR_BEARER_TOKEN_HERE>",
-});
+To access undocumented response properties, you may access the response object with `// @ts-expect-error` on
+the response object, or cast the response object to the requisite type. Like the request params, we do not
+validate or strip extra properties from the response from the API.
+
+### Customizing the fetch client
 
-async function run() {
-  const result = await zavu.sendMessage({
-    zavuSender: "sender_12345",
-    body: {
-      to: "+56912345678",
-      text: "Your verification code is 123456",
-    },
-  });
+By default, this library expects a global `fetch` function is defined.
 
-  console.log(result);
-}
+If you want to use a different `fetch` function, you can either polyfill the global:
 
-run();
+```ts
+import fetch from 'my-fetch';
 
+globalThis.fetch = fetch;
 ```
-<!-- End Server Selection [server] -->
 
-<!-- Start Custom HTTP Client [http-client] -->
-## Custom HTTP Client
+Or pass it to the client:
 
-The TypeScript SDK makes API calls using an `HTTPClient` that wraps the native
-[Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API). This
-client is a thin wrapper around `fetch` and provides the ability to attach hooks
-around the request lifecycle that can be used to modify the request or handle
-errors and response.
+```ts
+import Zavudev from '@zavudev/sdk';
+import fetch from 'my-fetch';
 
-The `HTTPClient` constructor takes an optional `fetcher` argument that can be
-used to integrate a third-party HTTP client or when writing tests to mock out
-the HTTP client and feed in fixtures.
+const client = new Zavudev({ fetch });
+```
 
-The following example shows how to use the `"beforeRequest"` hook to to add a
-custom header and a timeout to requests and how to use the `"requestError"` hook
-to log errors:
+### Fetch options
 
-```typescript
-import { Zavu } from "@zavudev/sdk";
-import { HTTPClient } from "@zavudev/sdk/lib/http";
+If you want to set custom `fetch` options without overriding the `fetch` function, you can provide a `fetchOptions` object when instantiating the client or making a request. (Request-specific options override client options.)
 
-const httpClient = new HTTPClient({
-  // fetcher takes a function that has the same signature as native `fetch`.
-  fetcher: (request) => {
-    return fetch(request);
-  }
+```ts
+import Zavudev from '@zavudev/sdk';
+
+const client = new Zavudev({
+  fetchOptions: {
+    // `RequestInit` options
+  },
 });
+```
+
+#### Configuring proxies
+
+To modify proxy behavior, you can provide custom `fetchOptions` that add runtime-specific proxy
+options to requests:
 
-httpClient.addHook("beforeRequest", (request) => {
-  const nextRequest = new Request(request, {
-    signal: request.signal || AbortSignal.timeout(5000)
-  });
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/node.svg" align="top" width="18" height="21"> **Node** <sup>[[docs](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md#example---proxyagent-with-fetch)]</sup>
 
-  nextRequest.headers.set("x-custom-header", "custom value");
+```ts
+import Zavudev from '@zavudev/sdk';
+import * as undici from 'undici';
 
-  return nextRequest;
+const proxyAgent = new undici.ProxyAgent('http://localhost:8888');
+const client = new Zavudev({
+  fetchOptions: {
+    dispatcher: proxyAgent,
+  },
 });
+```
+
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/bun.svg" align="top" width="18" height="21"> **Bun** <sup>[[docs](https://bun.sh/guides/http/proxy)]</sup>
+
+```ts
+import Zavudev from '@zavudev/sdk';
 
-httpClient.addHook("requestError", (error, request) => {
-  console.group("Request Error");
-  console.log("Reason:", `${error}`);
-  console.log("Endpoint:", `${request.method} ${request.url}`);
-  console.groupEnd();
+const client = new Zavudev({
+  fetchOptions: {
+    proxy: 'http://localhost:8888',
+  },
 });
+```
+
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/deno.svg" align="top" width="18" height="21"> **Deno** <sup>[[docs](https://docs.deno.com/api/deno/~/Deno.createHttpClient)]</sup>
 
-const sdk = new Zavu({ httpClient: httpClient });
+```ts
+import Zavudev from 'npm:@zavudev/sdk';
+
+const httpClient = Deno.createHttpClient({ proxy: { url: 'http://localhost:8888' } });
+const client = new Zavudev({
+  fetchOptions: {
+    client: httpClient,
+  },
+});
 ```
-<!-- End Custom HTTP Client [http-client] -->
 
-<!-- Start Debugging [debug] -->
-## Debugging
+## Frequently Asked Questions
 
-You can setup your SDK to emit debug logs for SDK requests and responses.
+## Semantic versioning
 
-You can pass a logger that matches `console`'s interface as an SDK option.
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
 
-> [!WARNING]
-> Beware that debug logging will reveal secrets, like API tokens in headers, in log messages printed to a console or files. It's recommended to use this feature only during local development and not in production.
+1. Changes that only affect static types, without breaking runtime behavior.
+2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+3. Changes that we do not expect to impact the vast majority of users in practice.
 
-```typescript
-import { Zavu } from "@zavudev/sdk";
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
 
-const sdk = new Zavu({ debugLogger: console });
-```
-<!-- End Debugging [debug] -->
+We are keen for your feedback; please open an [issue](https://www.github.com/zavudev/sdk-typescript/issues) with questions, bugs, or suggestions.
+
+## Requirements
 
-<!-- Placeholder for Future Speakeasy SDK Sections -->
+TypeScript >= 4.9 is supported.
 
-# Development
+The following runtimes are supported:
 
-## Maturity
+- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
+- Node.js 20 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
+- Deno v1.28.0 or higher.
+- Bun 1.0 or later.
+- Cloudflare Workers.
+- Vercel Edge Runtime.
+- Jest 28 or greater with the `"node"` environment (`"jsdom"` is not supported at this time).
+- Nitro v2.6 or greater.
 
-This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
-to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
-looking for the latest version.
+Note that React Native is not supported at this time.
 
-## Contributions
+If you are interested in other runtime environments, please open or upvote an issue on GitHub.
 
-While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation. 
-We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release. 
+## Contributing
 
-### SDK Created by [Speakeasy](https://www.speakeasy.com/?utm_source=@zavudev/sdk&utm_campaign=typescript)
+See [the contributing documentation](./CONTRIBUTING.md).