rutter-ts 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,188 @@
+# rutter-ts
+
+TypeScript SDK for the [Rutter API](https://docs.rutter.com). Includes a lightweight HTTP client, typed API wrappers with Zod response validation, and auto-generated types from the Rutter OpenAPI spec.
+
+## Install
+
+```bash
+npm install rutter-ts zod
+# or
+bun add rutter-ts zod
+```
+
+`zod` is a peer dependency (`>=3.23.0 || >=4.0.0`).
+
+## Entry Points
+
+The package is split into three entry points to support tree-shaking and bundle-size-sensitive environments (e.g. Convex, Cloudflare Workers):
+
+| Entry | What | Size |
+|---|---|---|
+| `rutter-ts` | Client, errors, types, constants | ~3KB |
+| `rutter-ts/api` | `RutterConnectionsApi`, `RutterAccountingApi` | ~5KB + generated |
+| `rutter-ts/generated` | All generated Zod validators + TypeScript types | ~500KB |
+
+If you're in a serverless environment with strict bundle limits, import the lightweight `rutter-ts` entry for queries/mutations and only import `rutter-ts/api` in contexts that allow larger bundles (e.g. Node.js actions).
+
+## Quick Start
+
+```typescript
+import { RutterClient, RUTTER_SANDBOX_BASE_URL } from 'rutter-ts'
+import { RutterConnectionsApi, RutterAccountingApi } from 'rutter-ts/api'
+
+const client = new RutterClient(
+  RUTTER_SANDBOX_BASE_URL,
+  process.env.RUTTER_CLIENT_ID,
+  process.env.RUTTER_CLIENT_SECRET,
+)
+
+const connections = new RutterConnectionsApi(client)
+const accounting = new RutterAccountingApi(client)
+```
+
+## Connections API
+
+```typescript
+// Create a connection
+const { connection } = await connections.create({ platform: 'QUICKBOOKS' })
+console.log(connection.link_url) // Rutter Link URL for the user
+
+// Exchange a public token for an access token
+const { access_token } = await connections.exchangeToken({
+  public_token: 'pt_...',
+})
+
+// List all connections
+const { connections: list } = await connections.list()
+
+// Get connection details by access token
+const { connection: details } = await connections.get(access_token)
+
+// Delete a connection
+await connections.delete(access_token)
+```
+
+## Accounting API
+
+```typescript
+// Get company info
+const { company_info } = await accounting.getCompanyInfo(accessToken)
+
+// List accounts (with pagination)
+const { accounts, next_cursor } = await accounting.listAccounts(accessToken, {
+  cursor: 'cur_...',
+})
+
+// Get a single account
+const { account } = await accounting.getAccount(accessToken, accountId)
+
+// List invoices
+const { invoices } = await accounting.listInvoices(accessToken)
+
+// Get a single invoice
+const { invoice } = await accounting.getInvoice(accessToken, invoiceId)
+
+// Create an invoice (with idempotency key)
+const { invoice: created } = await accounting.createInvoice(
+  accessToken,
+  {
+    customer_id: 'cust_...',
+    issue_date: '2024-07-01',
+    currency_code: 'USD',
+    line_items: [{ description: 'Consulting', total_amount: 5000 }],
+  },
+  'idem_unique_key',
+)
+```
+
+## Error Handling
+
+All API methods throw typed errors:
+
+```typescript
+import { RutterError, RutterSchemaMismatchError } from 'rutter-ts'
+
+try {
+  await connections.create({ platform: 'QUICKBOOKS' })
+} catch (e) {
+  if (e instanceof RutterError) {
+    console.error(e.status)        // HTTP status code
+    console.error(e.errorType)     // e.g. 'AUTHENTICATION_ERROR'
+    console.error(e.errorCode)     // e.g. 'invalid_credentials'
+    console.error(e.metadata)      // Optional error metadata
+
+    // Helpers
+    e.isRateLimited       // true for 429 (Rutter) or 452 (platform)
+    e.isUserActionable    // true for 400, 409, 410, 450
+    e.humanReadableMessage // metadata.human_readable ?? message
+  }
+
+  if (e instanceof RutterSchemaMismatchError) {
+    console.error(e.endpoint) // Which endpoint had the schema mismatch
+  }
+}
+```
+
+## Using Generated Types
+
+Import Zod validators and TypeScript types directly:
+
+```typescript
+import { zPlatform, zConnectionResponse } from 'rutter-ts/generated'
+import type { Invoice, Account, CompanyInfo20240430 } from 'rutter-ts/generated'
+```
+
+## Low-Level Client
+
+Use `RutterClient` directly for endpoints not yet wrapped by the API classes:
+
+```typescript
+import { RutterClient, RUTTER_PRODUCTION_BASE_URL } from 'rutter-ts'
+
+const client = new RutterClient(
+  RUTTER_PRODUCTION_BASE_URL,
+  clientId,
+  clientSecret,
+)
+
+// GET with query params
+const data = await client.get('/accounting/bills', {
+  access_token: 'at_...',
+  cursor: 'cur_...',
+})
+
+// POST with body and idempotency key
+const result = await client.post(
+  '/accounting/invoices?access_token=at_...',
+  { customer_id: 'cust_1', line_items: [] },
+  { idempotencyKey: 'unique_key' },
+)
+
+// PATCH and DELETE
+await client.patch('/some/endpoint', { field: 'value' })
+await client.delete('/connections', { access_token: 'at_...' })
+```
+
+## Constants
+
+```typescript
+import {
+  RUTTER_SANDBOX_BASE_URL,      // https://sandbox.rutterapi.com/versioned
+  RUTTER_PRODUCTION_BASE_URL,   // https://production.rutterapi.com/versioned
+  RUTTER_API_VERSION,           // 2024-08-31
+} from 'rutter-ts'
+```
+
+## Regenerating Types
+
+The generated types are built from the Rutter OpenAPI spec:
+
+```bash
+bun run generate
+```
+
+This runs `@hey-api/openapi-ts` against `https://docs.rutter.com/rest/2024-08-31/spec` and applies a post-generation fixup script.
+
+## License
+
+MIT

package/dist/api.cjs

@@ -0,0 +1,190 @@
+'use strict';
+
+var chunkLPP3MIOV_cjs = require('./chunk-LPP3MIOV.cjs');
+var chunkJCJXW7AE_cjs = require('./chunk-JCJXW7AE.cjs');
+var z2 = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var z2__default = /*#__PURE__*/_interopDefault(z2);
+
+var RutterConnectionsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    const endpoint = "/connections";
+    const response = await this.client.post(endpoint, params);
+    const result = chunkJCJXW7AE_cjs.zConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async list() {
+    const endpoint = "/connections";
+    const response = await this.client.get(endpoint);
+    const result = chunkJCJXW7AE_cjs.zListConnectionsResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async get(accessToken) {
+    const endpoint = "/connections";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = chunkJCJXW7AE_cjs.zGetAccessTokenConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async exchangeToken(params) {
+    const endpoint = "/item/public_token/exchange";
+    const response = await this.client.post(endpoint, params);
+    const result = chunkJCJXW7AE_cjs.zExchangeTokenResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async delete(accessToken) {
+    const endpoint = "/connections";
+    const response = await this.client.delete(endpoint, {
+      access_token: accessToken
+    });
+    const result = chunkJCJXW7AE_cjs.zDeleteConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+};
+var RutterAccountingApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getCompanyInfo(accessToken) {
+    const endpoint = "/accounting/company_info";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = chunkJCJXW7AE_cjs.zCompanyInfo20240430ResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async listAccounts(accessToken, params) {
+    const endpoint = "/accounting/accounts";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken,
+      ...params
+    });
+    const result = chunkJCJXW7AE_cjs.zListAccountResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async getAccount(accessToken, id) {
+    const endpoint = `/accounting/accounts/${id}`;
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = chunkJCJXW7AE_cjs.zAccountResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async listInvoices(accessToken, params) {
+    const endpoint = "/accounting/invoices";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken,
+      ...params
+    });
+    const result = chunkJCJXW7AE_cjs.zListInvoiceResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async getInvoice(accessToken, id) {
+    const endpoint = `/accounting/invoices/${id}`;
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = chunkJCJXW7AE_cjs.zInvoiceResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async createInvoice(accessToken, params, idempotencyKey) {
+    const endpoint = "/accounting/invoices";
+    const response = await this.client.post(
+      `${endpoint}?access_token=${encodeURIComponent(accessToken)}`,
+      params,
+      idempotencyKey ? { idempotencyKey } : void 0
+    );
+    const result = chunkJCJXW7AE_cjs.zCreateInvoiceResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async createCustomer(accessToken, params) {
+    const endpoint = "/accounting/customers";
+    const response = await this.client.post(
+      `${endpoint}?access_token=${encodeURIComponent(accessToken)}`,
+      { customer: params }
+    );
+    const result = chunkJCJXW7AE_cjs.zCreateAccountingCustomerResponse.safeParse(response);
+    if (!result.success) {
+      throw new chunkLPP3MIOV_cjs.RutterSchemaMismatchError(
+        endpoint,
+        z2__default.default.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+};
+
+exports.RutterAccountingApi = RutterAccountingApi;
+exports.RutterConnectionsApi = RutterConnectionsApi;

package/dist/api.d.cts

@@ -0,0 +1,43 @@
+import z__default from 'zod';
+import { b as RutterClient, c as RutterPaginationParams, d as RutterQueryParams } from './client-sPbSz2i_.cjs';
+import { zConnectionResponse, zListConnectionsResponse, zGetAccessTokenConnectionResponse, zExchangeTokenResponse, zDeleteConnectionResponse, zCompanyInfo20240430ResponseWithConnection, zListAccountResponseWithConnection, zAccountResponseWithConnection, zListInvoiceResponseWithConnection, zInvoiceResponseWithConnection, CreateInvoice, zCreateInvoiceResponse, CreateAccountingCustomer, zCreateAccountingCustomerResponse } from './generated.cjs';
+
+type TConnectionResponse = z__default.infer<typeof zConnectionResponse>;
+type TListConnectionsResponse = z__default.infer<typeof zListConnectionsResponse>;
+type TExchangeTokenResponse = z__default.infer<typeof zExchangeTokenResponse>;
+type TDeleteConnectionResponse = z__default.infer<typeof zDeleteConnectionResponse>;
+type TGetAccessTokenConnectionResponse = z__default.infer<typeof zGetAccessTokenConnectionResponse>;
+declare class RutterConnectionsApi {
+    private readonly client;
+    constructor(client: RutterClient);
+    create(params: {
+        platform: string;
+    }): Promise<TConnectionResponse>;
+    list(): Promise<TListConnectionsResponse>;
+    get(accessToken: string): Promise<TGetAccessTokenConnectionResponse>;
+    exchangeToken(params: {
+        public_token: string;
+    }): Promise<TExchangeTokenResponse>;
+    delete(accessToken: string): Promise<TDeleteConnectionResponse>;
+}
+
+type TCompanyInfoResponse = z__default.infer<typeof zCompanyInfo20240430ResponseWithConnection>;
+type TListAccountsResponse = z__default.infer<typeof zListAccountResponseWithConnection>;
+type TAccountResponse = z__default.infer<typeof zAccountResponseWithConnection>;
+type TListInvoicesResponse = z__default.infer<typeof zListInvoiceResponseWithConnection>;
+type TInvoiceResponse = z__default.infer<typeof zInvoiceResponseWithConnection>;
+type TCreateInvoiceResponse = z__default.infer<typeof zCreateInvoiceResponse>;
+type TCreateCustomerResponse = z__default.infer<typeof zCreateAccountingCustomerResponse>;
+declare class RutterAccountingApi {
+    private readonly client;
+    constructor(client: RutterClient);
+    getCompanyInfo(accessToken: string): Promise<TCompanyInfoResponse>;
+    listAccounts(accessToken: string, params?: RutterPaginationParams & RutterQueryParams): Promise<TListAccountsResponse>;
+    getAccount(accessToken: string, id: string): Promise<TAccountResponse>;
+    listInvoices(accessToken: string, params?: RutterPaginationParams & RutterQueryParams): Promise<TListInvoicesResponse>;
+    getInvoice(accessToken: string, id: string): Promise<TInvoiceResponse>;
+    createInvoice(accessToken: string, params: CreateInvoice, idempotencyKey?: string): Promise<TCreateInvoiceResponse>;
+    createCustomer(accessToken: string, params: CreateAccountingCustomer): Promise<TCreateCustomerResponse>;
+}
+
+export { RutterAccountingApi, RutterConnectionsApi };

package/dist/api.d.ts

@@ -0,0 +1,43 @@
+import z__default from 'zod';
+import { b as RutterClient, c as RutterPaginationParams, d as RutterQueryParams } from './client-sPbSz2i_.js';
+import { zConnectionResponse, zListConnectionsResponse, zGetAccessTokenConnectionResponse, zExchangeTokenResponse, zDeleteConnectionResponse, zCompanyInfo20240430ResponseWithConnection, zListAccountResponseWithConnection, zAccountResponseWithConnection, zListInvoiceResponseWithConnection, zInvoiceResponseWithConnection, CreateInvoice, zCreateInvoiceResponse, CreateAccountingCustomer, zCreateAccountingCustomerResponse } from './generated.js';
+
+type TConnectionResponse = z__default.infer<typeof zConnectionResponse>;
+type TListConnectionsResponse = z__default.infer<typeof zListConnectionsResponse>;
+type TExchangeTokenResponse = z__default.infer<typeof zExchangeTokenResponse>;
+type TDeleteConnectionResponse = z__default.infer<typeof zDeleteConnectionResponse>;
+type TGetAccessTokenConnectionResponse = z__default.infer<typeof zGetAccessTokenConnectionResponse>;
+declare class RutterConnectionsApi {
+    private readonly client;
+    constructor(client: RutterClient);
+    create(params: {
+        platform: string;
+    }): Promise<TConnectionResponse>;
+    list(): Promise<TListConnectionsResponse>;
+    get(accessToken: string): Promise<TGetAccessTokenConnectionResponse>;
+    exchangeToken(params: {
+        public_token: string;
+    }): Promise<TExchangeTokenResponse>;
+    delete(accessToken: string): Promise<TDeleteConnectionResponse>;
+}
+
+type TCompanyInfoResponse = z__default.infer<typeof zCompanyInfo20240430ResponseWithConnection>;
+type TListAccountsResponse = z__default.infer<typeof zListAccountResponseWithConnection>;
+type TAccountResponse = z__default.infer<typeof zAccountResponseWithConnection>;
+type TListInvoicesResponse = z__default.infer<typeof zListInvoiceResponseWithConnection>;
+type TInvoiceResponse = z__default.infer<typeof zInvoiceResponseWithConnection>;
+type TCreateInvoiceResponse = z__default.infer<typeof zCreateInvoiceResponse>;
+type TCreateCustomerResponse = z__default.infer<typeof zCreateAccountingCustomerResponse>;
+declare class RutterAccountingApi {
+    private readonly client;
+    constructor(client: RutterClient);
+    getCompanyInfo(accessToken: string): Promise<TCompanyInfoResponse>;
+    listAccounts(accessToken: string, params?: RutterPaginationParams & RutterQueryParams): Promise<TListAccountsResponse>;
+    getAccount(accessToken: string, id: string): Promise<TAccountResponse>;
+    listInvoices(accessToken: string, params?: RutterPaginationParams & RutterQueryParams): Promise<TListInvoicesResponse>;
+    getInvoice(accessToken: string, id: string): Promise<TInvoiceResponse>;
+    createInvoice(accessToken: string, params: CreateInvoice, idempotencyKey?: string): Promise<TCreateInvoiceResponse>;
+    createCustomer(accessToken: string, params: CreateAccountingCustomer): Promise<TCreateCustomerResponse>;
+}
+
+export { RutterAccountingApi, RutterConnectionsApi };

package/dist/api.js

@@ -0,0 +1,183 @@
+import { RutterSchemaMismatchError } from './chunk-LLGYUOGX.js';
+import { zConnectionResponse, zListConnectionsResponse, zGetAccessTokenConnectionResponse, zExchangeTokenResponse, zDeleteConnectionResponse, zCompanyInfo20240430ResponseWithConnection, zListAccountResponseWithConnection, zAccountResponseWithConnection, zListInvoiceResponseWithConnection, zInvoiceResponseWithConnection, zCreateInvoiceResponse, zCreateAccountingCustomerResponse } from './chunk-HSUL4OZU.js';
+import z2 from 'zod';
+
+var RutterConnectionsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    const endpoint = "/connections";
+    const response = await this.client.post(endpoint, params);
+    const result = zConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async list() {
+    const endpoint = "/connections";
+    const response = await this.client.get(endpoint);
+    const result = zListConnectionsResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async get(accessToken) {
+    const endpoint = "/connections";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = zGetAccessTokenConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async exchangeToken(params) {
+    const endpoint = "/item/public_token/exchange";
+    const response = await this.client.post(endpoint, params);
+    const result = zExchangeTokenResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async delete(accessToken) {
+    const endpoint = "/connections";
+    const response = await this.client.delete(endpoint, {
+      access_token: accessToken
+    });
+    const result = zDeleteConnectionResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+};
+var RutterAccountingApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getCompanyInfo(accessToken) {
+    const endpoint = "/accounting/company_info";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = zCompanyInfo20240430ResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async listAccounts(accessToken, params) {
+    const endpoint = "/accounting/accounts";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken,
+      ...params
+    });
+    const result = zListAccountResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async getAccount(accessToken, id) {
+    const endpoint = `/accounting/accounts/${id}`;
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = zAccountResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async listInvoices(accessToken, params) {
+    const endpoint = "/accounting/invoices";
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken,
+      ...params
+    });
+    const result = zListInvoiceResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async getInvoice(accessToken, id) {
+    const endpoint = `/accounting/invoices/${id}`;
+    const response = await this.client.get(endpoint, {
+      access_token: accessToken
+    });
+    const result = zInvoiceResponseWithConnection.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async createInvoice(accessToken, params, idempotencyKey) {
+    const endpoint = "/accounting/invoices";
+    const response = await this.client.post(
+      `${endpoint}?access_token=${encodeURIComponent(accessToken)}`,
+      params,
+      idempotencyKey ? { idempotencyKey } : void 0
+    );
+    const result = zCreateInvoiceResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+  async createCustomer(accessToken, params) {
+    const endpoint = "/accounting/customers";
+    const response = await this.client.post(
+      `${endpoint}?access_token=${encodeURIComponent(accessToken)}`,
+      { customer: params }
+    );
+    const result = zCreateAccountingCustomerResponse.safeParse(response);
+    if (!result.success) {
+      throw new RutterSchemaMismatchError(
+        endpoint,
+        z2.prettifyError(result.error)
+      );
+    }
+    return result.data;
+  }
+};
+
+export { RutterAccountingApi, RutterConnectionsApi };

package/dist/chunk-LLGYUOGX.js

@@ -0,0 +1,36 @@
+// src/errors.ts
+var RutterError = class extends Error {
+  status;
+  errorType;
+  errorCode;
+  metadata;
+  constructor(body, status) {
+    super(body.error_message);
+    this.name = "RutterError";
+    this.status = status;
+    this.errorType = body.error_type;
+    this.errorCode = body.error_code;
+    this.metadata = body.error_metadata;
+  }
+  get isRateLimited() {
+    return this.status === 429 || this.status === 452;
+  }
+  get isUserActionable() {
+    return this.status === 400 || this.status === 409 || this.status === 410 || this.status === 450;
+  }
+  get humanReadableMessage() {
+    return this.metadata?.human_readable ?? this.message;
+  }
+};
+var RutterSchemaMismatchError = class extends Error {
+  endpoint;
+  constructor(endpoint, issues) {
+    super(
+      `Rutter response from ${endpoint} failed schema validation: ${issues}`
+    );
+    this.name = "RutterSchemaMismatchError";
+    this.endpoint = endpoint;
+  }
+};
+
+export { RutterError, RutterSchemaMismatchError };