@dispatchtickets/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,923 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/errors.ts
+var DispatchTicketsError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.name = "DispatchTicketsError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AuthenticationError = class extends DispatchTicketsError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "authentication_error", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends DispatchTicketsError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, "rate_limit_error", 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends DispatchTicketsError {
+  errors;
+  constructor(message = "Validation failed", errors) {
+    super(message, "validation_error", 400, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var NotFoundError = class extends DispatchTicketsError {
+  resourceType;
+  resourceId;
+  constructor(message = "Resource not found", resourceType, resourceId) {
+    super(message, "not_found", 404, { resourceType, resourceId });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var ConflictError = class extends DispatchTicketsError {
+  constructor(message = "Resource conflict") {
+    super(message, "conflict", 409);
+    this.name = "ConflictError";
+  }
+};
+var ServerError = class extends DispatchTicketsError {
+  constructor(message = "Internal server error", statusCode = 500) {
+    super(message, "server_error", statusCode);
+    this.name = "ServerError";
+  }
+};
+var TimeoutError = class extends DispatchTicketsError {
+  constructor(message = "Request timed out") {
+    super(message, "timeout_error");
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends DispatchTicketsError {
+  constructor(message = "Network error") {
+    super(message, "network_error");
+    this.name = "NetworkError";
+  }
+};
+
+// src/utils/http.ts
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Execute an HTTP request with retry logic
+   */
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const headers = this.buildHeaders(options.headers, options.idempotencyKey);
+    let lastError;
+    let attempt = 0;
+    while (attempt <= this.config.maxRetries) {
+      try {
+        const response = await this.executeRequest(url, options.method, headers, options.body);
+        return await this.handleResponse(response);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof DispatchTicketsError) {
+          if (error instanceof AuthenticationError || error instanceof ValidationError || error instanceof NotFoundError || error instanceof ConflictError) {
+            throw error;
+          }
+          if (error instanceof RateLimitError && error.retryAfter) {
+            if (attempt < this.config.maxRetries) {
+              await this.sleep(error.retryAfter * 1e3);
+              attempt++;
+              continue;
+            }
+          }
+          if (error instanceof ServerError) {
+            if (attempt < this.config.maxRetries) {
+              await this.sleep(this.calculateBackoff(attempt));
+              attempt++;
+              continue;
+            }
+          }
+        }
+        if (error instanceof NetworkError || error instanceof TimeoutError) {
+          if (attempt < this.config.maxRetries) {
+            await this.sleep(this.calculateBackoff(attempt));
+            attempt++;
+            continue;
+          }
+        }
+        throw error;
+      }
+    }
+    throw lastError || new NetworkError("Request failed after retries");
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.config.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(customHeaders, idempotencyKey) {
+    const headers = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...customHeaders
+    };
+    if (idempotencyKey) {
+      headers["X-Idempotency-Key"] = idempotencyKey;
+    }
+    return headers;
+  }
+  async executeRequest(url, method, headers, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      if (this.config.debug) {
+        console.log(`[DispatchTickets] ${method} ${url}`);
+        if (body) {
+          console.log("[DispatchTickets] Body:", JSON.stringify(body, null, 2));
+        }
+      }
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new TimeoutError(`Request timed out after ${this.config.timeout}ms`);
+        }
+        throw new NetworkError(error.message);
+      }
+      throw new NetworkError("Unknown network error");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async handleResponse(response) {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    if (response.ok) {
+      if (response.status === 204 || !isJson) {
+        return void 0;
+      }
+      return await response.json();
+    }
+    let errorData = {};
+    if (isJson) {
+      try {
+        errorData = await response.json();
+      } catch {
+      }
+    }
+    const message = errorData.message || errorData.error || response.statusText;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 400:
+      case 422:
+        throw new ValidationError(message, errorData.errors);
+      case 404:
+        throw new NotFoundError(message);
+      case 409:
+        throw new ConflictError(message);
+      case 429: {
+        const retryAfter = response.headers.get("retry-after");
+        throw new RateLimitError(message, retryAfter ? parseInt(retryAfter, 10) : void 0);
+      }
+      default:
+        if (response.status >= 500) {
+          throw new ServerError(message, response.status);
+        }
+        throw new DispatchTicketsError(message, "api_error", response.status, errorData);
+    }
+  }
+  calculateBackoff(attempt) {
+    const baseDelay = 1e3;
+    const maxDelay = 3e4;
+    const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    return delay + Math.random() * delay * 0.25;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async _get(path, query) {
+    return this.http.request({
+      method: "GET",
+      path,
+      query
+    });
+  }
+  async _post(path, body, options) {
+    return this.http.request({
+      method: "POST",
+      path,
+      body,
+      idempotencyKey: options?.idempotencyKey,
+      query: options?.query
+    });
+  }
+  async _patch(path, body) {
+    return this.http.request({
+      method: "PATCH",
+      path,
+      body
+    });
+  }
+  async _put(path, body) {
+    return this.http.request({
+      method: "PUT",
+      path,
+      body
+    });
+  }
+  async _delete(path, query) {
+    return this.http.request({
+      method: "DELETE",
+      path,
+      query
+    });
+  }
+};
+
+// src/resources/brands.ts
+var BrandsResource = class extends BaseResource {
+  /**
+   * Create a new brand
+   */
+  async create(data) {
+    return this._post("/brands", data);
+  }
+  /**
+   * List all brands
+   */
+  async list() {
+    return this._get("/brands");
+  }
+  /**
+   * Get a brand by ID
+   */
+  async get(brandId) {
+    return this._get(`/brands/${brandId}`);
+  }
+  /**
+   * Update a brand
+   */
+  async update(brandId, data) {
+    return this._patch(`/brands/${brandId}`, data);
+  }
+  /**
+   * Delete a brand
+   * @param brandId - The brand ID
+   * @param confirm - Set to true to actually delete; false to preview what would be deleted
+   */
+  async delete(brandId, confirm = true) {
+    if (confirm) {
+      await this._delete(`/brands/${brandId}`, { confirm: true });
+      return;
+    }
+    return this._delete(`/brands/${brandId}`);
+  }
+  /**
+   * Get the ticket schema for a brand
+   */
+  async getSchema(brandId) {
+    return this._get(`/brands/${brandId}/schema`);
+  }
+  /**
+   * Update the ticket schema for a brand
+   */
+  async updateSchema(brandId, schema) {
+    return this._put(`/brands/${brandId}/schema`, schema);
+  }
+};
+
+// src/resources/tickets.ts
+var TicketsResource = class extends BaseResource {
+  /**
+   * Create a new ticket
+   */
+  async create(brandId, data, options) {
+    return this._post(`/brands/${brandId}/tickets`, data, {
+      idempotencyKey: options?.idempotencyKey
+    });
+  }
+  /**
+   * List tickets with pagination (async iterator)
+   * Automatically fetches all pages
+   */
+  async *list(brandId, filters) {
+    let cursor;
+    let hasMore = true;
+    while (hasMore) {
+      const page = await this.listPage(brandId, { ...filters, cursor });
+      for (const ticket of page.data) {
+        yield ticket;
+      }
+      cursor = page.pagination.cursor;
+      hasMore = page.pagination.hasMore;
+    }
+  }
+  /**
+   * List a single page of tickets
+   */
+  async listPage(brandId, filters) {
+    const query = this.buildListQuery(filters);
+    return this._get(`/brands/${brandId}/tickets`, query);
+  }
+  /**
+   * Get a ticket by ID
+   */
+  async get(brandId, ticketId) {
+    return this._get(`/brands/${brandId}/tickets/${ticketId}`);
+  }
+  /**
+   * Update a ticket
+   */
+  async update(brandId, ticketId, data) {
+    return this._patch(`/brands/${brandId}/tickets/${ticketId}`, data);
+  }
+  /**
+   * Delete a ticket
+   */
+  async delete(brandId, ticketId) {
+    return this._delete(`/brands/${brandId}/tickets/${ticketId}`);
+  }
+  /**
+   * Mark a ticket as spam or not spam
+   */
+  async markAsSpam(brandId, ticketId, isSpam) {
+    return this._post(`/brands/${brandId}/tickets/${ticketId}/spam`, { isSpam });
+  }
+  /**
+   * Merge tickets into a target ticket
+   */
+  async merge(brandId, targetTicketId, sourceTicketIds) {
+    return this._post(`/brands/${brandId}/tickets/${targetTicketId}/merge`, {
+      sourceTicketIds
+    });
+  }
+  /**
+   * Perform a bulk action on multiple tickets
+   */
+  async bulk(brandId, action, ticketIds, options) {
+    return this._post(`/brands/${brandId}/tickets/bulk`, {
+      action,
+      ticketIds,
+      ...options
+    });
+  }
+  buildListQuery(filters) {
+    if (!filters) return {};
+    const query = {};
+    if (filters.status) {
+      query.status = Array.isArray(filters.status) ? filters.status.join(",") : filters.status;
+    }
+    if (filters.priority) query.priority = filters.priority;
+    if (filters.assigneeId) query.assigneeId = filters.assigneeId;
+    if (filters.customerId) query.customerId = filters.customerId;
+    if (filters.customerEmail) query.customerEmail = filters.customerEmail;
+    if (filters.createdBy) query.createdBy = filters.createdBy;
+    if (filters.createdAfter) query.createdAfter = filters.createdAfter;
+    if (filters.createdBefore) query.createdBefore = filters.createdBefore;
+    if (filters.hasAttachments !== void 0) query.hasAttachments = filters.hasAttachments;
+    if (filters.isSpam !== void 0) query.isSpam = filters.isSpam;
+    if (filters.search) query.search = filters.search;
+    if (filters.categoryId) query.categoryId = filters.categoryId;
+    if (filters.tagIds) query.tagIds = filters.tagIds.join(",");
+    if (filters.source) query.source = filters.source;
+    if (filters.sort) query.sort = filters.sort;
+    if (filters.order) query.order = filters.order;
+    if (filters.limit) query.limit = filters.limit;
+    if (filters.cursor) query.cursor = filters.cursor;
+    return query;
+  }
+};
+
+// src/resources/comments.ts
+var CommentsResource = class extends BaseResource {
+  /**
+   * Create a new comment on a ticket
+   */
+  async create(brandId, ticketId, data, options) {
+    return this._post(
+      `/brands/${brandId}/tickets/${ticketId}/comments`,
+      data,
+      { idempotencyKey: options?.idempotencyKey }
+    );
+  }
+  /**
+   * List all comments on a ticket
+   */
+  async list(brandId, ticketId) {
+    return this._get(`/brands/${brandId}/tickets/${ticketId}/comments`);
+  }
+  /**
+   * Get a comment by ID
+   */
+  async get(brandId, ticketId, commentId) {
+    return this._get(
+      `/brands/${brandId}/tickets/${ticketId}/comments/${commentId}`
+    );
+  }
+  /**
+   * Update a comment
+   */
+  async update(brandId, ticketId, commentId, data) {
+    return this._patch(
+      `/brands/${brandId}/tickets/${ticketId}/comments/${commentId}`,
+      data
+    );
+  }
+  /**
+   * Delete a comment
+   */
+  async delete(brandId, ticketId, commentId) {
+    return this._delete(
+      `/brands/${brandId}/tickets/${ticketId}/comments/${commentId}`
+    );
+  }
+};
+
+// src/resources/attachments.ts
+var AttachmentsResource = class extends BaseResource {
+  /**
+   * Initiate an upload and get a presigned URL
+   */
+  async initiateUpload(brandId, ticketId, data) {
+    return this._post(
+      `/brands/${brandId}/tickets/${ticketId}/attachments`,
+      data
+    );
+  }
+  /**
+   * Confirm that an upload has completed
+   */
+  async confirmUpload(brandId, ticketId, attachmentId) {
+    return this._post(
+      `/brands/${brandId}/tickets/${ticketId}/attachments/${attachmentId}/confirm`
+    );
+  }
+  /**
+   * List all attachments on a ticket
+   */
+  async list(brandId, ticketId) {
+    return this._get(`/brands/${brandId}/tickets/${ticketId}/attachments`);
+  }
+  /**
+   * Get an attachment with its download URL
+   */
+  async get(brandId, ticketId, attachmentId) {
+    return this._get(
+      `/brands/${brandId}/tickets/${ticketId}/attachments/${attachmentId}`
+    );
+  }
+  /**
+   * Delete an attachment
+   */
+  async delete(brandId, ticketId, attachmentId) {
+    await this._delete(
+      `/brands/${brandId}/tickets/${ticketId}/attachments/${attachmentId}`
+    );
+  }
+  /**
+   * Convenience method: Upload a file in one step
+   * Handles: initiate -> upload to presigned URL -> confirm
+   */
+  async upload(brandId, ticketId, file, filename, contentType) {
+    let size;
+    if (file instanceof Blob) {
+      size = file.size;
+    } else if (Buffer.isBuffer(file)) {
+      size = file.length;
+    } else {
+      size = file.byteLength;
+    }
+    const { uploadUrl, attachmentId } = await this.initiateUpload(brandId, ticketId, {
+      filename,
+      contentType,
+      size
+    });
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": String(size)
+      },
+      body: file
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+    }
+    return this.confirmUpload(brandId, ticketId, attachmentId);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class extends BaseResource {
+  /**
+   * Create a new webhook
+   */
+  async create(brandId, data) {
+    return this._post(`/brands/${brandId}/webhooks`, data);
+  }
+  /**
+   * List all webhooks for a brand
+   */
+  async list(brandId) {
+    return this._get(`/brands/${brandId}/webhooks`);
+  }
+  /**
+   * Get a webhook by ID
+   */
+  async get(brandId, webhookId) {
+    return this._get(`/brands/${brandId}/webhooks/${webhookId}`);
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(brandId, webhookId) {
+    await this._delete(`/brands/${brandId}/webhooks/${webhookId}`);
+  }
+  /**
+   * Get webhook delivery history
+   */
+  async getDeliveries(brandId, webhookId) {
+    return this._get(
+      `/brands/${brandId}/webhooks/${webhookId}/deliveries`
+    );
+  }
+};
+
+// src/resources/categories.ts
+var CategoriesResource = class extends BaseResource {
+  /**
+   * Create a new category
+   */
+  async create(brandId, data) {
+    return this._post(`/brands/${brandId}/categories`, data);
+  }
+  /**
+   * List all categories for a brand
+   */
+  async list(brandId) {
+    return this._get(`/brands/${brandId}/categories`);
+  }
+  /**
+   * Get a category by ID
+   */
+  async get(brandId, categoryId) {
+    return this._get(`/brands/${brandId}/categories/${categoryId}`);
+  }
+  /**
+   * Update a category
+   */
+  async update(brandId, categoryId, data) {
+    return this._patch(`/brands/${brandId}/categories/${categoryId}`, data);
+  }
+  /**
+   * Delete a category
+   */
+  async delete(brandId, categoryId) {
+    await this._delete(`/brands/${brandId}/categories/${categoryId}`);
+  }
+  /**
+   * Get category statistics (ticket counts)
+   */
+  async getStats(brandId) {
+    return this._get(`/brands/${brandId}/categories/stats`);
+  }
+  /**
+   * Reorder categories
+   */
+  async reorder(brandId, categoryIds) {
+    await this._post(`/brands/${brandId}/categories/reorder`, { categoryIds });
+  }
+};
+
+// src/resources/tags.ts
+var TagsResource = class extends BaseResource {
+  /**
+   * Create a new tag
+   */
+  async create(brandId, data) {
+    return this._post(`/brands/${brandId}/tags`, data);
+  }
+  /**
+   * List all tags for a brand
+   */
+  async list(brandId) {
+    return this._get(`/brands/${brandId}/tags`);
+  }
+  /**
+   * Update a tag
+   */
+  async update(brandId, tagId, data) {
+    return this._patch(`/brands/${brandId}/tags/${tagId}`, data);
+  }
+  /**
+   * Delete a tag
+   */
+  async delete(brandId, tagId) {
+    await this._delete(`/brands/${brandId}/tags/${tagId}`);
+  }
+  /**
+   * Merge tags into a target tag
+   */
+  async merge(brandId, targetTagId, sourceTagIds) {
+    return this._post(`/brands/${brandId}/tags/${targetTagId}/merge`, {
+      sourceTagIds
+    });
+  }
+};
+
+// src/resources/customers.ts
+var CustomersResource = class extends BaseResource {
+  /**
+   * Create a new customer
+   */
+  async create(brandId, data) {
+    return this._post(`/brands/${brandId}/customers`, data);
+  }
+  /**
+   * List customers with pagination (async iterator)
+   */
+  async *list(brandId, filters) {
+    let cursor;
+    let hasMore = true;
+    while (hasMore) {
+      const page = await this.listPage(brandId, { ...filters, cursor });
+      for (const customer of page.data) {
+        yield customer;
+      }
+      cursor = page.pagination.cursor;
+      hasMore = page.pagination.hasMore;
+    }
+  }
+  /**
+   * List a single page of customers
+   */
+  async listPage(brandId, filters) {
+    const query = this.buildListQuery(filters);
+    return this._get(`/brands/${brandId}/customers`, query);
+  }
+  /**
+   * Search customers (autocomplete)
+   */
+  async search(brandId, query) {
+    return this._get(`/brands/${brandId}/customers/search`, { q: query });
+  }
+  /**
+   * Get a customer by ID
+   */
+  async get(brandId, customerId) {
+    return this._get(`/brands/${brandId}/customers/${customerId}`);
+  }
+  /**
+   * Update a customer
+   */
+  async update(brandId, customerId, data) {
+    return this._patch(`/brands/${brandId}/customers/${customerId}`, data);
+  }
+  /**
+   * Delete a customer
+   */
+  async delete(brandId, customerId) {
+    return this._delete(`/brands/${brandId}/customers/${customerId}`);
+  }
+  buildListQuery(filters) {
+    if (!filters) return {};
+    const query = {};
+    if (filters.limit) query.limit = filters.limit;
+    if (filters.cursor) query.cursor = filters.cursor;
+    if (filters.sort) query.sort = filters.sort;
+    if (filters.order) query.order = filters.order;
+    return query;
+  }
+};
+
+// src/resources/fields.ts
+var FieldsResource = class extends BaseResource {
+  /**
+   * Get all field definitions for a brand
+   */
+  async getAll(brandId) {
+    return this._get(`/brands/${brandId}/fields`);
+  }
+  /**
+   * Get field definitions for a specific entity type
+   */
+  async list(brandId, entityType) {
+    return this._get(`/brands/${brandId}/fields/${entityType}`);
+  }
+  /**
+   * Create a new field definition
+   */
+  async create(brandId, entityType, data) {
+    return this._post(`/brands/${brandId}/fields/${entityType}`, data);
+  }
+  /**
+   * Update a field definition
+   */
+  async update(brandId, entityType, key, data) {
+    return this._patch(
+      `/brands/${brandId}/fields/${entityType}/${key}`,
+      data
+    );
+  }
+  /**
+   * Delete a field definition
+   */
+  async delete(brandId, entityType, key) {
+    await this._delete(`/brands/${brandId}/fields/${entityType}/${key}`);
+  }
+  /**
+   * Reorder field definitions
+   */
+  async reorder(brandId, entityType, keys) {
+    await this._post(`/brands/${brandId}/fields/${entityType}/reorder`, { keys });
+  }
+};
+var webhookUtils = {
+  /**
+   * Verify a webhook signature
+   *
+   * @param payload - The raw request body as a string
+   * @param signature - The X-Dispatch-Signature header value
+   * @param secret - Your webhook secret
+   * @returns true if the signature is valid
+   *
+   * @example
+   * ```typescript
+   * import { DispatchTickets } from '@dispatchtickets/sdk';
+   *
+   * app.post('/webhooks', (req, res) => {
+   *   const signature = req.headers['x-dispatch-signature'];
+   *   const isValid = DispatchTickets.webhooks.verifySignature(
+   *     req.rawBody,
+   *     signature,
+   *     process.env.WEBHOOK_SECRET
+   *   );
+   *
+   *   if (!isValid) {
+   *     return res.status(401).send('Invalid signature');
+   *   }
+   *
+   *   // Process webhook...
+   * });
+   * ```
+   */
+  verifySignature(payload, signature, secret) {
+    if (!signature || !secret) {
+      return false;
+    }
+    const parts = signature.split("=");
+    if (parts.length !== 2 || parts[0] !== "sha256") {
+      return false;
+    }
+    const receivedSignature = parts[1];
+    const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+    try {
+      const receivedBuffer = Buffer.from(receivedSignature, "hex");
+      const expectedBuffer = Buffer.from(expectedSignature, "hex");
+      if (receivedBuffer.length !== expectedBuffer.length) {
+        return false;
+      }
+      return crypto.timingSafeEqual(receivedBuffer, expectedBuffer);
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Generate a signature for testing purposes
+   *
+   * @param payload - The payload to sign
+   * @param secret - The secret to sign with
+   * @returns The signature in the format sha256=<hex>
+   */
+  generateSignature(payload, secret) {
+    const signature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+    return `sha256=${signature}`;
+  }
+};
+
+// src/client.ts
+var DispatchTickets = class {
+  http;
+  /**
+   * Brands (workspaces) resource
+   */
+  brands;
+  /**
+   * Tickets resource
+   */
+  tickets;
+  /**
+   * Comments resource
+   */
+  comments;
+  /**
+   * Attachments resource
+   */
+  attachments;
+  /**
+   * Webhooks resource
+   */
+  webhooks;
+  /**
+   * Categories resource
+   */
+  categories;
+  /**
+   * Tags resource
+   */
+  tags;
+  /**
+   * Customers resource
+   */
+  customers;
+  /**
+   * Custom fields resource
+   */
+  fields;
+  /**
+   * Static webhook utilities
+   */
+  static webhooks = webhookUtils;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    const httpConfig = {
+      baseUrl: config.baseUrl || "https://dispatch-tickets-api.onrender.com/v1",
+      apiKey: config.apiKey,
+      timeout: config.timeout ?? 3e4,
+      maxRetries: config.maxRetries ?? 3,
+      debug: config.debug ?? false
+    };
+    this.http = new HttpClient(httpConfig);
+    this.brands = new BrandsResource(this.http);
+    this.tickets = new TicketsResource(this.http);
+    this.comments = new CommentsResource(this.http);
+    this.attachments = new AttachmentsResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.categories = new CategoriesResource(this.http);
+    this.tags = new TagsResource(this.http);
+    this.customers = new CustomersResource(this.http);
+    this.fields = new FieldsResource(this.http);
+  }
+};
+
+// src/utils/pagination.ts
+async function collectAll(iterable) {
+  const items = [];
+  for await (const item of iterable) {
+    items.push(item);
+  }
+  return items;
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.ConflictError = ConflictError;
+exports.DispatchTickets = DispatchTickets;
+exports.DispatchTicketsError = DispatchTicketsError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.collectAll = collectAll;
+exports.webhookUtils = webhookUtils;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map