@workbenchcrm/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1082 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClientsResource: () => ClientsResource,
+  InvoicesResource: () => InvoicesResource,
+  JobsResource: () => JobsResource,
+  QuotesResource: () => QuotesResource,
+  ServiceRequestsResource: () => ServiceRequestsResource,
+  WebhookVerificationError: () => WebhookVerificationError,
+  WebhooksResource: () => WebhooksResource,
+  WorkbenchClient: () => WorkbenchClient,
+  WorkbenchError: () => WorkbenchError,
+  computeSignature: () => computeSignature,
+  constructWebhookEvent: () => constructWebhookEvent,
+  parseSignatureHeader: () => parseSignatureHeader,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/resources/clients.ts
+var ClientsResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all clients
+   *
+   * Returns a paginated list of clients for the authenticated business.
+   *
+   * @param options - List options (pagination, filtering, sorting)
+   * @returns Paginated list of clients
+   *
+   * @example
+   * ```typescript
+   * // List all active clients
+   * const { data, pagination } = await workbench.clients.list({
+   *   status: 'active',
+   *   page: 1,
+   *   per_page: 20
+   * });
+   *
+   * console.log(`Found ${pagination.total} clients`);
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/clients", {
+      page: options.page,
+      per_page: options.per_page,
+      search: options.search,
+      sort: options.sort,
+      order: options.order,
+      status: options.status
+    });
+  }
+  /**
+   * Get a client by ID
+   *
+   * @param id - Client UUID
+   * @returns Client details
+   *
+   * @example
+   * ```typescript
+   * const { data: client } = await workbench.clients.get('client-uuid');
+   * console.log(`Client: ${client.first_name} ${client.last_name}`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/clients/${id}`);
+  }
+  /**
+   * Create a new client
+   *
+   * @param data - Client data
+   * @returns Created client
+   *
+   * @example
+   * ```typescript
+   * const { data: client } = await workbench.clients.create({
+   *   first_name: 'John',
+   *   last_name: 'Doe',
+   *   email: 'john@example.com',
+   *   phone: '+1-555-123-4567',
+   *   company: 'Acme Corp',
+   *   status: 'active',
+   *   source: 'referral',
+   *   tags: ['vip', 'commercial']
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/clients", data);
+  }
+  /**
+   * Update a client
+   *
+   * @param id - Client UUID
+   * @param data - Fields to update
+   * @returns Updated client
+   *
+   * @example
+   * ```typescript
+   * const { data: client } = await workbench.clients.update('client-uuid', {
+   *   status: 'inactive',
+   *   notes: 'Client requested to pause services'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/clients/${id}`, data);
+  }
+  /**
+   * Delete a client
+   *
+   * Permanently deletes a client and all associated data.
+   * This action cannot be undone.
+   *
+   * @param id - Client UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.clients.delete('client-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/clients/${id}`);
+  }
+};
+
+// src/resources/invoices.ts
+var InvoicesResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all invoices
+   *
+   * Returns a paginated list of invoices for the authenticated business.
+   *
+   * @param options - List options (pagination, filtering, sorting)
+   * @returns Paginated list of invoices
+   *
+   * @example
+   * ```typescript
+   * // List unpaid invoices
+   * const { data, pagination } = await workbench.invoices.list({
+   *   status: 'sent',
+   *   per_page: 50
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/invoices", {
+      page: options.page,
+      per_page: options.per_page,
+      search: options.search,
+      sort: options.sort,
+      order: options.order,
+      status: options.status,
+      client_id: options.client_id
+    });
+  }
+  /**
+   * Get an invoice by ID
+   *
+   * @param id - Invoice UUID
+   * @returns Invoice details with line items
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await workbench.invoices.get('invoice-uuid');
+   * console.log(`Invoice ${invoice.invoice_number}: $${invoice.total}`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/invoices/${id}`);
+  }
+  /**
+   * Create a new invoice
+   *
+   * Creates an invoice with line items. The invoice number is
+   * automatically generated by Workbench.
+   *
+   * @param data - Invoice data including line items
+   * @returns Created invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await workbench.invoices.create({
+   *   client_id: 'client-uuid',
+   *   due_date: '2024-02-15',
+   *   items: [
+   *     { description: 'Web Development', quantity: 10, unit_price: 100 }
+   *   ],
+   *   tax_rate: 8.5,
+   *   notes: 'Payment due within 30 days'
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/invoices", data);
+  }
+  /**
+   * Update an invoice
+   *
+   * If items are provided, they will replace all existing line items.
+   *
+   * @param id - Invoice UUID
+   * @param data - Fields to update
+   * @returns Updated invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await workbench.invoices.update('invoice-uuid', {
+   *   status: 'paid',
+   *   notes: 'Paid via bank transfer on 2024-01-15'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/invoices/${id}`, data);
+  }
+  /**
+   * Delete an invoice
+   *
+   * Permanently deletes an invoice and all associated line items.
+   * This action cannot be undone.
+   *
+   * @param id - Invoice UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.invoices.delete('invoice-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/invoices/${id}`);
+  }
+  /**
+   * Send an invoice via email
+   *
+   * Sends the invoice to the client's email address. The invoice
+   * status will be updated to 'sent' if currently 'draft'.
+   *
+   * @param id - Invoice UUID
+   * @returns Success response
+   *
+   * @example
+   * ```typescript
+   * await workbench.invoices.send('invoice-uuid');
+   * console.log('Invoice sent successfully');
+   * ```
+   */
+  async send(id) {
+    return this.client.post(`/v1/invoices/${id}/send`);
+  }
+};
+
+// src/resources/quotes.ts
+var QuotesResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all quotes
+   *
+   * Returns a paginated list of quotes for the authenticated business.
+   *
+   * @param options - List options (pagination, filtering, sorting)
+   * @returns Paginated list of quotes
+   *
+   * @example
+   * ```typescript
+   * // List pending quotes
+   * const { data, pagination } = await workbench.quotes.list({
+   *   status: 'sent',
+   *   per_page: 20
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/quotes", {
+      page: options.page,
+      per_page: options.per_page,
+      search: options.search,
+      sort: options.sort,
+      order: options.order,
+      status: options.status,
+      client_id: options.client_id
+    });
+  }
+  /**
+   * Get a quote by ID
+   *
+   * @param id - Quote UUID
+   * @returns Quote details with line items
+   *
+   * @example
+   * ```typescript
+   * const { data: quote } = await workbench.quotes.get('quote-uuid');
+   * console.log(`Quote ${quote.quote_number}: $${quote.total}`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/quotes/${id}`);
+  }
+  /**
+   * Create a new quote
+   *
+   * Creates a quote with line items. The quote number is
+   * automatically generated by Workbench.
+   *
+   * @param data - Quote data including line items
+   * @returns Created quote
+   *
+   * @example
+   * ```typescript
+   * const { data: quote } = await workbench.quotes.create({
+   *   client_id: 'client-uuid',
+   *   valid_until: '2024-03-01',
+   *   items: [
+   *     { description: 'Plumbing Service', quantity: 4, unit_price: 75 }
+   *   ],
+   *   notes: 'Quote valid for 30 days',
+   *   terms: 'Payment due upon completion'
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/quotes", data);
+  }
+  /**
+   * Update a quote
+   *
+   * If items are provided, they will replace all existing line items.
+   *
+   * @param id - Quote UUID
+   * @param data - Fields to update
+   * @returns Updated quote
+   *
+   * @example
+   * ```typescript
+   * const { data: quote } = await workbench.quotes.update('quote-uuid', {
+   *   status: 'approved',
+   *   notes: 'Client approved via email on 2024-01-15'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/quotes/${id}`, data);
+  }
+  /**
+   * Delete a quote
+   *
+   * Permanently deletes a quote and all associated line items.
+   * This action cannot be undone.
+   *
+   * @param id - Quote UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.quotes.delete('quote-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/quotes/${id}`);
+  }
+  /**
+   * Send a quote via email
+   *
+   * Sends the quote to the client's email address. The quote
+   * status will be updated to 'sent' if currently 'draft'.
+   *
+   * @param id - Quote UUID
+   * @returns Success response
+   *
+   * @example
+   * ```typescript
+   * await workbench.quotes.send('quote-uuid');
+   * console.log('Quote sent successfully');
+   * ```
+   */
+  async send(id) {
+    return this.client.post(`/v1/quotes/${id}/send`);
+  }
+};
+
+// src/resources/jobs.ts
+var JobsResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all jobs
+   *
+   * Returns a paginated list of jobs for the authenticated business.
+   *
+   * @param options - List options (pagination, filtering, sorting)
+   * @returns Paginated list of jobs
+   *
+   * @example
+   * ```typescript
+   * // List scheduled jobs
+   * const { data, pagination } = await workbench.jobs.list({
+   *   status: 'scheduled',
+   *   priority: 'high',
+   *   per_page: 20
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/jobs", {
+      page: options.page,
+      per_page: options.per_page,
+      search: options.search,
+      sort: options.sort,
+      order: options.order,
+      status: options.status,
+      priority: options.priority,
+      client_id: options.client_id
+    });
+  }
+  /**
+   * Get a job by ID
+   *
+   * @param id - Job UUID
+   * @returns Job details
+   *
+   * @example
+   * ```typescript
+   * const { data: job } = await workbench.jobs.get('job-uuid');
+   * console.log(`Job: ${job.title} (${job.status})`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/jobs/${id}`);
+  }
+  /**
+   * Create a new job
+   *
+   * @param data - Job data
+   * @returns Created job
+   *
+   * @example
+   * ```typescript
+   * const { data: job } = await workbench.jobs.create({
+   *   client_id: 'client-uuid',
+   *   title: 'HVAC Maintenance',
+   *   description: 'Annual AC maintenance and filter replacement',
+   *   priority: 'medium',
+   *   scheduled_start: '2024-01-25T10:00:00Z',
+   *   estimated_duration: 120, // minutes
+   *   notes: 'Customer prefers morning appointments'
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/jobs", data);
+  }
+  /**
+   * Update a job
+   *
+   * @param id - Job UUID
+   * @param data - Fields to update
+   * @returns Updated job
+   *
+   * @example
+   * ```typescript
+   * // Mark job as started
+   * const { data: job } = await workbench.jobs.update('job-uuid', {
+   *   status: 'in_progress',
+   *   actual_start: new Date().toISOString()
+   * });
+   *
+   * // Mark job as completed
+   * await workbench.jobs.update('job-uuid', {
+   *   status: 'completed',
+   *   actual_end: new Date().toISOString()
+   * });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/jobs/${id}`, data);
+  }
+  /**
+   * Delete a job
+   *
+   * Permanently deletes a job. This action cannot be undone.
+   *
+   * @param id - Job UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.jobs.delete('job-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/jobs/${id}`);
+  }
+};
+
+// src/resources/service-requests.ts
+var ServiceRequestsResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all service requests
+   *
+   * Returns a paginated list of service requests for the authenticated business.
+   *
+   * @param options - List options (pagination, filtering, sorting)
+   * @returns Paginated list of service requests
+   *
+   * @example
+   * ```typescript
+   * // List new requests
+   * const { data, pagination } = await workbench.serviceRequests.list({
+   *   status: 'new',
+   *   priority: 'urgent',
+   *   per_page: 50
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/service-requests", {
+      page: options.page,
+      per_page: options.per_page,
+      search: options.search,
+      sort: options.sort,
+      order: options.order,
+      status: options.status,
+      priority: options.priority,
+      client_id: options.client_id
+    });
+  }
+  /**
+   * Get a service request by ID
+   *
+   * @param id - Service request UUID
+   * @returns Service request details
+   *
+   * @example
+   * ```typescript
+   * const { data: request } = await workbench.serviceRequests.get('request-uuid');
+   * console.log(`Request: ${request.title} (${request.status})`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/service-requests/${id}`);
+  }
+  /**
+   * Create a new service request
+   *
+   * @param data - Service request data
+   * @returns Created service request
+   *
+   * @example
+   * ```typescript
+   * const { data: request } = await workbench.serviceRequests.create({
+   *   title: 'AC Not Cooling',
+   *   description: 'Air conditioner is running but not producing cold air',
+   *   contact_name: 'John Doe',
+   *   contact_email: 'john@example.com',
+   *   contact_phone: '+1-555-123-4567',
+   *   address: '456 Oak Ave, Anytown, USA',
+   *   priority: 'urgent',
+   *   requested_date: '2024-01-20',
+   *   preferred_time: 'Morning (8am-12pm)',
+   *   source: 'website'
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/service-requests", data);
+  }
+  /**
+   * Update a service request
+   *
+   * @param id - Service request UUID
+   * @param data - Fields to update
+   * @returns Updated service request
+   *
+   * @example
+   * ```typescript
+   * // Assign to client and schedule
+   * const { data: request } = await workbench.serviceRequests.update('request-uuid', {
+   *   client_id: 'client-uuid',
+   *   status: 'scheduled',
+   *   notes: 'Scheduled for Monday morning'
+   * });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/service-requests/${id}`, data);
+  }
+  /**
+   * Delete a service request
+   *
+   * Permanently deletes a service request. This action cannot be undone.
+   *
+   * @param id - Service request UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.serviceRequests.delete('request-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/service-requests/${id}`);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all webhooks
+   *
+   * Returns a paginated list of webhook subscriptions for the authenticated business.
+   *
+   * @param options - List options (pagination)
+   * @returns Paginated list of webhooks
+   *
+   * @example
+   * ```typescript
+   * const { data: webhooks } = await workbench.webhooks.list();
+   * webhooks.forEach(webhook => {
+   *   console.log(`${webhook.name}: ${webhook.events.join(', ')}`);
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    return this.client.get("/v1/webhooks", {
+      page: options.page,
+      per_page: options.per_page
+    });
+  }
+  /**
+   * Get a webhook by ID
+   *
+   * @param id - Webhook UUID
+   * @returns Webhook details
+   *
+   * @example
+   * ```typescript
+   * const { data: webhook } = await workbench.webhooks.get('webhook-uuid');
+   * console.log(`Webhook: ${webhook.name}`);
+   * console.log(`Events: ${webhook.events.join(', ')}`);
+   * ```
+   */
+  async get(id) {
+    return this.client.get(`/v1/webhooks/${id}`);
+  }
+  /**
+   * Create a new webhook
+   *
+   * Creates a webhook subscription. The webhook secret is returned
+   * in the response - store it securely to verify webhook signatures.
+   *
+   * @param data - Webhook data
+   * @returns Created webhook (includes secret)
+   *
+   * @example
+   * ```typescript
+   * const { data: webhook } = await workbench.webhooks.create({
+   *   name: 'All Events',
+   *   url: 'https://example.com/webhooks',
+   *   events: [
+   *     'client.created',
+   *     'client.updated',
+   *     'invoice.created',
+   *     'invoice.paid',
+   *     'quote.accepted',
+   *     'job.completed'
+   *   ]
+   * });
+   *
+   * // IMPORTANT: Store the secret securely!
+   * console.log('Store this secret:', webhook.secret);
+   * ```
+   */
+  async create(data) {
+    return this.client.post("/v1/webhooks", data);
+  }
+  /**
+   * Update a webhook
+   *
+   * @param id - Webhook UUID
+   * @param data - Fields to update
+   * @returns Updated webhook
+   *
+   * @example
+   * ```typescript
+   * // Add more events to the webhook
+   * const { data: webhook } = await workbench.webhooks.update('webhook-uuid', {
+   *   events: ['invoice.created', 'invoice.paid', 'invoice.overdue']
+   * });
+   *
+   * // Disable a webhook
+   * await workbench.webhooks.update('webhook-uuid', { is_active: false });
+   * ```
+   */
+  async update(id, data) {
+    return this.client.put(`/v1/webhooks/${id}`, data);
+  }
+  /**
+   * Delete a webhook
+   *
+   * Permanently deletes a webhook subscription. No more events
+   * will be sent to this endpoint.
+   *
+   * @param id - Webhook UUID
+   *
+   * @example
+   * ```typescript
+   * await workbench.webhooks.delete('webhook-uuid');
+   * ```
+   */
+  async delete(id) {
+    await this.client.delete(`/v1/webhooks/${id}`);
+  }
+  /**
+   * List webhook deliveries
+   *
+   * Returns recent delivery attempts for a webhook. Useful for
+   * debugging and monitoring webhook health.
+   *
+   * @param webhookId - Webhook UUID
+   * @param options - List options (pagination, filtering)
+   * @returns Paginated list of delivery attempts
+   *
+   * @example
+   * ```typescript
+   * const { data: deliveries } = await workbench.webhooks.listDeliveries('webhook-uuid', {
+   *   per_page: 50
+   * });
+   *
+   * deliveries.forEach(delivery => {
+   *   const status = delivery.delivered_at ? 'delivered' : 'pending';
+   *   console.log(`${delivery.event_type}: ${status}`);
+   * });
+   * ```
+   */
+  async listDeliveries(webhookId, options = {}) {
+    return this.client.get(`/v1/webhooks/${webhookId}/deliveries`, {
+      page: options.page,
+      per_page: options.per_page,
+      event_type: options.event_type
+    });
+  }
+  /**
+   * Send a test webhook
+   *
+   * Sends a test event to the webhook endpoint. Useful for
+   * verifying your webhook handler is working correctly.
+   *
+   * @param id - Webhook UUID
+   * @returns Test delivery result
+   *
+   * @example
+   * ```typescript
+   * const { data: result } = await workbench.webhooks.test('webhook-uuid');
+   * console.log('Test delivery:', result);
+   * ```
+   */
+  async test(id) {
+    return this.client.post(`/v1/webhooks/${id}/test`);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.tryworkbench.app";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var WorkbenchError = class extends Error {
+  /** HTTP status code */
+  status;
+  /** Error code from the API */
+  code;
+  /** Additional error details */
+  details;
+  /** Request ID for debugging */
+  requestId;
+  constructor(message, status, code, details, requestId) {
+    super(message);
+    this.name = "WorkbenchError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.requestId = requestId;
+  }
+};
+var WorkbenchClient = class {
+  baseUrl;
+  timeout;
+  maxRetries;
+  authHeader;
+  /** Clients resource */
+  clients;
+  /** Invoices resource */
+  invoices;
+  /** Quotes resource */
+  quotes;
+  /** Jobs resource */
+  jobs;
+  /** Service requests resource */
+  serviceRequests;
+  /** Webhooks resource */
+  webhooks;
+  /**
+   * Create a new Workbench client
+   *
+   * @param config - Client configuration
+   * @throws Error if neither apiKey nor accessToken is provided
+   */
+  constructor(config) {
+    if (!config.apiKey && !config.accessToken) {
+      throw new Error("Either apiKey or accessToken must be provided");
+    }
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries || DEFAULT_MAX_RETRIES;
+    const token = config.accessToken || config.apiKey;
+    this.authHeader = `Bearer ${token}`;
+    this.clients = new ClientsResource(this);
+    this.invoices = new InvoicesResource(this);
+    this.quotes = new QuotesResource(this);
+    this.jobs = new JobsResource(this);
+    this.serviceRequests = new ServiceRequestsResource(this);
+    this.webhooks = new WebhooksResource(this);
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Sleep for a specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Calculate exponential backoff delay
+   */
+  getRetryDelay(attempt) {
+    return Math.min(1e3 * Math.pow(2, attempt), 1e4);
+  }
+  /**
+   * Determine if an error is retryable
+   */
+  isRetryable(status) {
+    return status === 429 || status >= 500 && status < 600;
+  }
+  /**
+   * Make an API request
+   *
+   * @param options - Request options
+   * @returns API response
+   * @throws WorkbenchError if the request fails
+   */
+  async request(options) {
+    const { method, path, query, body, headers } = options;
+    const url = this.buildUrl(path, query);
+    const requestHeaders = {
+      "Authorization": this.authHeader,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...headers
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          method,
+          headers: requestHeaders,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const responseText = await response.text();
+        let responseData;
+        try {
+          responseData = responseText ? JSON.parse(responseText) : {};
+        } catch {
+          throw new WorkbenchError(
+            "Invalid JSON response from API",
+            response.status,
+            "INVALID_RESPONSE"
+          );
+        }
+        if (!response.ok) {
+          const errorResponse = responseData;
+          if (this.isRetryable(response.status) && attempt < this.maxRetries) {
+            const delay = this.getRetryDelay(attempt);
+            await this.sleep(delay);
+            continue;
+          }
+          throw new WorkbenchError(
+            errorResponse.error?.message || "Unknown error",
+            response.status,
+            errorResponse.error?.code || "UNKNOWN_ERROR",
+            errorResponse.error?.details,
+            errorResponse.meta?.request_id
+          );
+        }
+        return responseData;
+      } catch (error) {
+        if (error instanceof WorkbenchError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new WorkbenchError(
+            "Request timeout",
+            0,
+            "TIMEOUT"
+          );
+        } else {
+          lastError = error instanceof Error ? error : new Error(String(error));
+        }
+        if (attempt < this.maxRetries) {
+          const delay = this.getRetryDelay(attempt);
+          await this.sleep(delay);
+          continue;
+        }
+      }
+    }
+    throw lastError || new WorkbenchError("Request failed", 0, "UNKNOWN_ERROR");
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+};
+
+// src/utils/webhook-verify.ts
+var import_crypto = require("crypto");
+var WebhookVerificationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+function parseSignatureHeader(header) {
+  if (!header || typeof header !== "string") {
+    throw new WebhookVerificationError("Missing or invalid signature header");
+  }
+  const parts = header.split(",");
+  let timestamp;
+  let signature;
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (key === "t") {
+      timestamp = parseInt(value, 10);
+      if (isNaN(timestamp)) {
+        throw new WebhookVerificationError("Invalid timestamp in signature header");
+      }
+    } else if (key === "v1") {
+      signature = value;
+    }
+  }
+  if (timestamp === void 0 || !signature) {
+    throw new WebhookVerificationError("Invalid signature header format");
+  }
+  return { timestamp, signature };
+}
+function computeSignature(payload, secret, timestamp) {
+  const payloadString = typeof payload === "string" ? payload : payload.toString("utf8");
+  const signedPayload = `${timestamp}.${payloadString}`;
+  return (0, import_crypto.createHmac)("sha256", secret).update(signedPayload).digest("hex");
+}
+function verifyWebhookSignature(payload, signature, secret, options = {}) {
+  const { tolerance = 300 } = options;
+  const { timestamp, signature: providedSignature } = parseSignatureHeader(signature);
+  if (tolerance > 0) {
+    const now = Math.floor(Date.now() / 1e3);
+    const age = now - timestamp;
+    if (age > tolerance) {
+      throw new WebhookVerificationError(
+        `Webhook timestamp is too old (${age} seconds). Maximum allowed age is ${tolerance} seconds.`
+      );
+    }
+    if (age < -tolerance) {
+      throw new WebhookVerificationError(
+        "Webhook timestamp is in the future. Check your server clock."
+      );
+    }
+  }
+  const expectedSignature = computeSignature(payload, secret, timestamp);
+  const expectedBuffer = Buffer.from(expectedSignature, "utf8");
+  const providedBuffer = Buffer.from(providedSignature, "utf8");
+  if (expectedBuffer.length !== providedBuffer.length) {
+    throw new WebhookVerificationError("Invalid webhook signature");
+  }
+  if (!(0, import_crypto.timingSafeEqual)(expectedBuffer, providedBuffer)) {
+    throw new WebhookVerificationError("Invalid webhook signature");
+  }
+  return true;
+}
+function constructWebhookEvent(payload, signature, secret, options = {}) {
+  verifyWebhookSignature(payload, signature, secret, options);
+  const payloadString = typeof payload === "string" ? payload : payload.toString("utf8");
+  try {
+    return JSON.parse(payloadString);
+  } catch {
+    throw new WebhookVerificationError("Invalid webhook payload: not valid JSON");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClientsResource,
+  InvoicesResource,
+  JobsResource,
+  QuotesResource,
+  ServiceRequestsResource,
+  WebhookVerificationError,
+  WebhooksResource,
+  WorkbenchClient,
+  WorkbenchError,
+  computeSignature,
+  constructWebhookEvent,
+  parseSignatureHeader,
+  verifyWebhookSignature
+});