@dispatchtickets/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1116 @@
+interface HttpClientConfig {
+    baseUrl: string;
+    apiKey: string;
+    timeout: number;
+    maxRetries: number;
+    debug?: boolean;
+}
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+    path: string;
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+}
+/**
+ * HTTP client with retry logic and error handling
+ */
+declare class HttpClient {
+    private readonly config;
+    constructor(config: HttpClientConfig);
+    /**
+     * Execute an HTTP request with retry logic
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+    private buildUrl;
+    private buildHeaders;
+    private executeRequest;
+    private handleResponse;
+    private calculateBackoff;
+    private sleep;
+}
+
+/**
+ * Base class for all resource classes
+ */
+declare abstract class BaseResource {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+    protected _get<T>(path: string, query?: RequestOptions['query']): Promise<T>;
+    protected _post<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        query?: RequestOptions['query'];
+    }): Promise<T>;
+    protected _patch<T>(path: string, body?: unknown): Promise<T>;
+    protected _put<T>(path: string, body?: unknown): Promise<T>;
+    protected _delete<T>(path: string, query?: RequestOptions['query']): Promise<T>;
+}
+
+/**
+ * Brand (workspace) resource
+ */
+interface Brand {
+    id: string;
+    accountId: string;
+    name: string;
+    slug: string;
+    ticketPrefix?: string;
+    nextTicketNumber: number;
+    url?: string;
+    iconUrl?: string;
+    settings?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    ticketSchema?: Record<string, unknown>;
+    fieldDefinitions?: Record<string, unknown>;
+    inboundEmailEnabled: boolean;
+    autoresponseEnabled: boolean;
+    autoresponseSubject?: string;
+    autoresponseBody?: string;
+    fromName?: string;
+    fromEmail?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Input for creating a brand
+ */
+interface CreateBrandInput {
+    name: string;
+    slug: string;
+    ticketPrefix?: string;
+    ticketNumberStart?: number;
+    metadata?: Record<string, unknown>;
+    ticketSchema?: Record<string, unknown>;
+}
+/**
+ * Input for updating a brand
+ */
+interface UpdateBrandInput {
+    name?: string;
+    slug?: string;
+    ticketPrefix?: string;
+    url?: string;
+    iconUrl?: string;
+    fromName?: string;
+    fromEmail?: string;
+    autoresponseEnabled?: boolean;
+    autoresponseSubject?: string;
+    autoresponseBody?: string;
+    metadata?: Record<string, unknown>;
+    ticketSchema?: Record<string, unknown>;
+}
+/**
+ * Brand deletion preview result
+ */
+interface DeleteBrandPreview {
+    ticketCount: number;
+    webhookCount: number;
+    categoryCount: number;
+    tagCount: number;
+}
+
+/**
+ * Brands resource for managing workspaces
+ */
+declare class BrandsResource extends BaseResource {
+    /**
+     * Create a new brand
+     */
+    create(data: CreateBrandInput): Promise<Brand>;
+    /**
+     * List all brands
+     */
+    list(): Promise<Brand[]>;
+    /**
+     * Get a brand by ID
+     */
+    get(brandId: string): Promise<Brand>;
+    /**
+     * Update a brand
+     */
+    update(brandId: string, data: UpdateBrandInput): Promise<Brand>;
+    /**
+     * Delete a brand
+     * @param brandId - The brand ID
+     * @param confirm - Set to true to actually delete; false to preview what would be deleted
+     */
+    delete(brandId: string, confirm?: boolean): Promise<void | DeleteBrandPreview>;
+    /**
+     * Get the ticket schema for a brand
+     */
+    getSchema(brandId: string): Promise<Record<string, unknown>>;
+    /**
+     * Update the ticket schema for a brand
+     */
+    updateSchema(brandId: string, schema: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+
+/**
+ * Pagination response wrapper
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        cursor?: string;
+        hasMore: boolean;
+    };
+}
+/**
+ * Link object for ticket/comment links
+ */
+interface Link {
+    url: string;
+    title?: string;
+    type?: string;
+}
+/**
+ * Ticket source channels
+ */
+type TicketSource = 'api' | 'web' | 'email' | 'slack' | 'sms' | 'discord' | 'instagram' | 'twitter' | 'whatsapp' | 'custom';
+/**
+ * Ticket status values
+ */
+type TicketStatus = 'open' | 'pending' | 'resolved' | 'closed';
+/**
+ * Ticket priority values
+ */
+type TicketPriority = 'low' | 'normal' | 'medium' | 'high' | 'urgent';
+/**
+ * Comment author types
+ */
+type AuthorType = 'CUSTOMER' | 'AGENT' | 'SYSTEM';
+/**
+ * Attachment status values
+ */
+type AttachmentStatus = 'PENDING' | 'UPLOADED' | 'FAILED';
+/**
+ * Webhook event types
+ */
+type WebhookEvent = 'ticket.created' | 'ticket.updated' | 'ticket.deleted' | 'comment.created' | 'comment.updated' | 'comment.deleted' | 'attachment.created' | 'attachment.deleted';
+/**
+ * Custom field types
+ */
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'select' | 'multiselect' | 'url' | 'array' | 'object';
+/**
+ * Entity types for custom fields
+ */
+type EntityType = 'ticket' | 'customer' | 'company';
+/**
+ * Bulk action types
+ */
+type BulkAction = 'spam' | 'resolve' | 'close' | 'delete' | 'assign' | 'setCategory' | 'setTags';
+/**
+ * Sort order
+ */
+type SortOrder = 'asc' | 'desc';
+
+/**
+ * Category resource
+ */
+interface Category {
+    id: string;
+    brandId: string;
+    name: string;
+    color: string;
+    description?: string;
+    sortOrder: number;
+    createdAt: string;
+}
+/**
+ * Input for creating a category
+ */
+interface CreateCategoryInput {
+    name: string;
+    color?: string;
+    description?: string;
+    sortOrder?: number;
+}
+/**
+ * Input for updating a category
+ */
+interface UpdateCategoryInput {
+    name?: string;
+    color?: string;
+    description?: string;
+    sortOrder?: number;
+}
+/**
+ * Category stats
+ */
+interface CategoryStats {
+    [categoryId: string]: {
+        ticketCount: number;
+    };
+}
+
+/**
+ * Tag resource
+ */
+interface Tag {
+    id: string;
+    brandId: string;
+    name: string;
+    color: string;
+    createdAt: string;
+}
+/**
+ * Input for creating a tag
+ */
+interface CreateTagInput {
+    name: string;
+    color?: string;
+}
+/**
+ * Input for updating a tag
+ */
+interface UpdateTagInput {
+    name?: string;
+    color?: string;
+}
+/**
+ * Input for merging tags
+ */
+interface MergeTagsInput {
+    sourceTagIds: string[];
+}
+
+/**
+ * Customer resource
+ */
+interface Customer {
+    id: string;
+    brandId: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    companyId?: string;
+    company?: Company;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        tickets: number;
+    };
+}
+/**
+ * Company resource
+ */
+interface Company {
+    id: string;
+    brandId: string;
+    name: string;
+    domain?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        customers: number;
+    };
+}
+/**
+ * Input for creating a customer
+ */
+interface CreateCustomerInput {
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    companyId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for updating a customer
+ */
+interface UpdateCustomerInput {
+    email?: string;
+    name?: string;
+    avatarUrl?: string;
+    companyId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Filters for listing customers
+ */
+interface ListCustomersFilters {
+    limit?: number;
+    cursor?: string;
+    sort?: 'createdAt' | 'name' | 'email';
+    order?: SortOrder;
+}
+
+/**
+ * Ticket resource
+ */
+interface Ticket {
+    id: string;
+    brandId: string;
+    ticketNumber: number;
+    title: string;
+    body?: string;
+    status: TicketStatus;
+    priority: TicketPriority;
+    assigneeId?: string;
+    createdBy?: string;
+    customerId?: string;
+    customer?: Customer;
+    categoryId?: string;
+    category?: Category;
+    tags?: Tag[];
+    links?: Link[];
+    customFields?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    source: TicketSource;
+    sourceId?: string;
+    sourceData?: Record<string, unknown>;
+    commentCount: number;
+    attachmentCount: number;
+    isSpam: boolean;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+    mergedIntoId?: string;
+}
+/**
+ * Input for creating a ticket
+ */
+interface CreateTicketInput {
+    title: string;
+    body?: string;
+    status?: TicketStatus;
+    priority?: TicketPriority;
+    assigneeId?: string;
+    createdBy?: string;
+    categoryId?: string;
+    tags?: string[];
+    links?: Link[];
+    customFields?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    source?: TicketSource;
+    sourceId?: string;
+    sourceData?: Record<string, unknown>;
+    notifyCustomer?: boolean;
+}
+/**
+ * Input for updating a ticket
+ */
+interface UpdateTicketInput {
+    title?: string;
+    body?: string;
+    status?: TicketStatus;
+    priority?: TicketPriority;
+    assigneeId?: string | null;
+    categoryId?: string | null;
+    tags?: string[];
+    links?: Link[];
+    customFields?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    isSpam?: boolean;
+}
+/**
+ * Filters for listing tickets
+ */
+interface ListTicketsFilters {
+    status?: TicketStatus | TicketStatus[] | 'active';
+    priority?: TicketPriority;
+    assigneeId?: string;
+    customerId?: string;
+    customerEmail?: string;
+    createdBy?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    hasAttachments?: boolean;
+    isSpam?: boolean;
+    search?: string;
+    categoryId?: string;
+    tagIds?: string[];
+    source?: TicketSource;
+    sort?: 'createdAt' | 'updatedAt' | 'priority';
+    order?: SortOrder;
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Options for creating a ticket
+ */
+interface CreateTicketOptions {
+    idempotencyKey?: string;
+}
+/**
+ * Input for merging tickets
+ */
+interface MergeTicketsInput {
+    sourceTicketIds: string[];
+}
+/**
+ * Result of a bulk action
+ */
+interface BulkActionResult {
+    success: boolean;
+    count: number;
+}
+
+/**
+ * Tickets resource
+ */
+declare class TicketsResource extends BaseResource {
+    /**
+     * Create a new ticket
+     */
+    create(brandId: string, data: CreateTicketInput, options?: CreateTicketOptions): Promise<Ticket>;
+    /**
+     * List tickets with pagination (async iterator)
+     * Automatically fetches all pages
+     */
+    list(brandId: string, filters?: Omit<ListTicketsFilters, 'cursor'>): AsyncIterable<Ticket>;
+    /**
+     * List a single page of tickets
+     */
+    listPage(brandId: string, filters?: ListTicketsFilters): Promise<PaginatedResponse<Ticket>>;
+    /**
+     * Get a ticket by ID
+     */
+    get(brandId: string, ticketId: string): Promise<Ticket>;
+    /**
+     * Update a ticket
+     */
+    update(brandId: string, ticketId: string, data: UpdateTicketInput): Promise<Ticket>;
+    /**
+     * Delete a ticket
+     */
+    delete(brandId: string, ticketId: string): Promise<Ticket>;
+    /**
+     * Mark a ticket as spam or not spam
+     */
+    markAsSpam(brandId: string, ticketId: string, isSpam: boolean): Promise<Ticket>;
+    /**
+     * Merge tickets into a target ticket
+     */
+    merge(brandId: string, targetTicketId: string, sourceTicketIds: string[]): Promise<Ticket>;
+    /**
+     * Perform a bulk action on multiple tickets
+     */
+    bulk(brandId: string, action: BulkAction, ticketIds: string[], options?: {
+        assigneeId?: string | null;
+        categoryId?: string | null;
+        tags?: string[];
+    }): Promise<BulkActionResult>;
+    private buildListQuery;
+}
+
+/**
+ * Comment resource
+ */
+interface Comment {
+    id: string;
+    ticketId: string;
+    body: string;
+    authorId?: string;
+    authorName?: string;
+    authorType: AuthorType;
+    parentId?: string;
+    links?: Link[];
+    metadata?: Record<string, unknown>;
+    source: TicketSource;
+    sourceId?: string;
+    sourceData?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+    replies?: Comment[];
+}
+/**
+ * Input for creating a comment
+ */
+interface CreateCommentInput {
+    body: string;
+    authorId?: string;
+    authorName?: string;
+    authorType?: AuthorType;
+    parentId?: string;
+    links?: Link[];
+    metadata?: Record<string, unknown>;
+    source?: TicketSource;
+    sourceId?: string;
+    sourceData?: Record<string, unknown>;
+    setStatus?: Exclude<TicketStatus, 'closed'>;
+    connectionId?: string;
+    cc?: string[];
+}
+/**
+ * Input for updating a comment
+ */
+interface UpdateCommentInput {
+    body?: string;
+    links?: Link[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for creating a comment
+ */
+interface CreateCommentOptions {
+    idempotencyKey?: string;
+}
+
+/**
+ * Comments resource
+ */
+declare class CommentsResource extends BaseResource {
+    /**
+     * Create a new comment on a ticket
+     */
+    create(brandId: string, ticketId: string, data: CreateCommentInput, options?: CreateCommentOptions): Promise<Comment>;
+    /**
+     * List all comments on a ticket
+     */
+    list(brandId: string, ticketId: string): Promise<Comment[]>;
+    /**
+     * Get a comment by ID
+     */
+    get(brandId: string, ticketId: string, commentId: string): Promise<Comment>;
+    /**
+     * Update a comment
+     */
+    update(brandId: string, ticketId: string, commentId: string, data: UpdateCommentInput): Promise<Comment>;
+    /**
+     * Delete a comment
+     */
+    delete(brandId: string, ticketId: string, commentId: string): Promise<Comment>;
+}
+
+/**
+ * Attachment resource
+ */
+interface Attachment {
+    id: string;
+    ticketId: string;
+    commentId?: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    status: AttachmentStatus;
+    uploadedBy?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Attachment with download URL
+ */
+interface AttachmentWithUrl extends Attachment {
+    downloadUrl: string;
+}
+/**
+ * Input for initiating an upload
+ */
+interface InitiateUploadInput {
+    filename: string;
+    contentType: string;
+    size: number;
+    uploadedBy?: string;
+}
+/**
+ * Response from initiating an upload
+ */
+interface InitiateUploadResponse {
+    attachmentId: string;
+    uploadUrl: string;
+    expiresIn: number;
+}
+
+/**
+ * Attachments resource
+ */
+declare class AttachmentsResource extends BaseResource {
+    /**
+     * Initiate an upload and get a presigned URL
+     */
+    initiateUpload(brandId: string, ticketId: string, data: InitiateUploadInput): Promise<InitiateUploadResponse>;
+    /**
+     * Confirm that an upload has completed
+     */
+    confirmUpload(brandId: string, ticketId: string, attachmentId: string): Promise<Attachment>;
+    /**
+     * List all attachments on a ticket
+     */
+    list(brandId: string, ticketId: string): Promise<Attachment[]>;
+    /**
+     * Get an attachment with its download URL
+     */
+    get(brandId: string, ticketId: string, attachmentId: string): Promise<AttachmentWithUrl>;
+    /**
+     * Delete an attachment
+     */
+    delete(brandId: string, ticketId: string, attachmentId: string): Promise<void>;
+    /**
+     * Convenience method: Upload a file in one step
+     * Handles: initiate -> upload to presigned URL -> confirm
+     */
+    upload(brandId: string, ticketId: string, file: Blob | Buffer | ArrayBuffer, filename: string, contentType: string): Promise<Attachment>;
+}
+
+/**
+ * Webhook resource
+ */
+interface Webhook {
+    id: string;
+    brandId: string;
+    url: string;
+    events: WebhookEvent[];
+    enabled: boolean;
+    failureCount: number;
+    lastTriggered?: string;
+    lastFailure?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Input for creating a webhook
+ */
+interface CreateWebhookInput {
+    url: string;
+    secret: string;
+    events: WebhookEvent[];
+}
+/**
+ * Webhook delivery record
+ */
+interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    event: WebhookEvent;
+    payload: Record<string, unknown>;
+    status: 'PENDING' | 'SUCCESS' | 'FAILED' | 'RETRYING';
+    attempts: number;
+    lastAttempt?: string;
+    responseCode?: number;
+    responseBody?: string;
+    error?: string;
+    createdAt: string;
+}
+
+/**
+ * Webhooks resource
+ */
+declare class WebhooksResource extends BaseResource {
+    /**
+     * Create a new webhook
+     */
+    create(brandId: string, data: CreateWebhookInput): Promise<Webhook>;
+    /**
+     * List all webhooks for a brand
+     */
+    list(brandId: string): Promise<Webhook[]>;
+    /**
+     * Get a webhook by ID
+     */
+    get(brandId: string, webhookId: string): Promise<Webhook>;
+    /**
+     * Delete a webhook
+     */
+    delete(brandId: string, webhookId: string): Promise<void>;
+    /**
+     * Get webhook delivery history
+     */
+    getDeliveries(brandId: string, webhookId: string): Promise<WebhookDelivery[]>;
+}
+
+/**
+ * Categories resource
+ */
+declare class CategoriesResource extends BaseResource {
+    /**
+     * Create a new category
+     */
+    create(brandId: string, data: CreateCategoryInput): Promise<Category>;
+    /**
+     * List all categories for a brand
+     */
+    list(brandId: string): Promise<Category[]>;
+    /**
+     * Get a category by ID
+     */
+    get(brandId: string, categoryId: string): Promise<Category>;
+    /**
+     * Update a category
+     */
+    update(brandId: string, categoryId: string, data: UpdateCategoryInput): Promise<Category>;
+    /**
+     * Delete a category
+     */
+    delete(brandId: string, categoryId: string): Promise<void>;
+    /**
+     * Get category statistics (ticket counts)
+     */
+    getStats(brandId: string): Promise<CategoryStats>;
+    /**
+     * Reorder categories
+     */
+    reorder(brandId: string, categoryIds: string[]): Promise<void>;
+}
+
+/**
+ * Tags resource
+ */
+declare class TagsResource extends BaseResource {
+    /**
+     * Create a new tag
+     */
+    create(brandId: string, data: CreateTagInput): Promise<Tag>;
+    /**
+     * List all tags for a brand
+     */
+    list(brandId: string): Promise<Tag[]>;
+    /**
+     * Update a tag
+     */
+    update(brandId: string, tagId: string, data: UpdateTagInput): Promise<Tag>;
+    /**
+     * Delete a tag
+     */
+    delete(brandId: string, tagId: string): Promise<void>;
+    /**
+     * Merge tags into a target tag
+     */
+    merge(brandId: string, targetTagId: string, sourceTagIds: string[]): Promise<Tag>;
+}
+
+/**
+ * Customers resource
+ */
+declare class CustomersResource extends BaseResource {
+    /**
+     * Create a new customer
+     */
+    create(brandId: string, data: CreateCustomerInput): Promise<Customer>;
+    /**
+     * List customers with pagination (async iterator)
+     */
+    list(brandId: string, filters?: Omit<ListCustomersFilters, 'cursor'>): AsyncIterable<Customer>;
+    /**
+     * List a single page of customers
+     */
+    listPage(brandId: string, filters?: ListCustomersFilters): Promise<PaginatedResponse<Customer>>;
+    /**
+     * Search customers (autocomplete)
+     */
+    search(brandId: string, query: string): Promise<Customer[]>;
+    /**
+     * Get a customer by ID
+     */
+    get(brandId: string, customerId: string): Promise<Customer>;
+    /**
+     * Update a customer
+     */
+    update(brandId: string, customerId: string, data: UpdateCustomerInput): Promise<Customer>;
+    /**
+     * Delete a customer
+     */
+    delete(brandId: string, customerId: string): Promise<Customer>;
+    private buildListQuery;
+}
+
+/**
+ * Custom field definition
+ */
+interface FieldDefinition {
+    key: string;
+    label: string;
+    type: FieldType;
+    required: boolean;
+    defaultValue?: unknown;
+    description?: string;
+    placeholder?: string;
+    options?: string[];
+    visible: boolean;
+    sortOrder: number;
+    source?: string;
+    createdAt?: string;
+}
+/**
+ * Field definitions grouped by entity type
+ */
+interface FieldDefinitions {
+    ticket: FieldDefinition[];
+    customer: FieldDefinition[];
+    company: FieldDefinition[];
+}
+/**
+ * Input for creating a field definition
+ */
+interface CreateFieldInput {
+    key: string;
+    label: string;
+    type: FieldType;
+    required?: boolean;
+    defaultValue?: unknown;
+    description?: string;
+    placeholder?: string;
+    options?: string[];
+    visible?: boolean;
+    sortOrder?: number;
+    source?: string;
+}
+/**
+ * Input for updating a field definition
+ */
+interface UpdateFieldInput {
+    label?: string;
+    required?: boolean;
+    defaultValue?: unknown;
+    description?: string;
+    placeholder?: string;
+    options?: string[];
+    visible?: boolean;
+    sortOrder?: number;
+}
+
+/**
+ * Custom fields resource
+ */
+declare class FieldsResource extends BaseResource {
+    /**
+     * Get all field definitions for a brand
+     */
+    getAll(brandId: string): Promise<FieldDefinitions>;
+    /**
+     * Get field definitions for a specific entity type
+     */
+    list(brandId: string, entityType: EntityType): Promise<FieldDefinition[]>;
+    /**
+     * Create a new field definition
+     */
+    create(brandId: string, entityType: EntityType, data: CreateFieldInput): Promise<FieldDefinition>;
+    /**
+     * Update a field definition
+     */
+    update(brandId: string, entityType: EntityType, key: string, data: UpdateFieldInput): Promise<FieldDefinition>;
+    /**
+     * Delete a field definition
+     */
+    delete(brandId: string, entityType: EntityType, key: string): Promise<void>;
+    /**
+     * Reorder field definitions
+     */
+    reorder(brandId: string, entityType: EntityType, keys: string[]): Promise<void>;
+}
+
+/**
+ * Configuration options for the Dispatch Tickets client
+ */
+interface DispatchTicketsConfig {
+    /**
+     * Your API key (required)
+     */
+    apiKey: string;
+    /**
+     * Base URL for the API
+     * @default 'https://dispatch-tickets-api.onrender.com/v1'
+     */
+    baseUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Maximum number of retries for failed requests
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Dispatch Tickets SDK client
+ *
+ * @example
+ * ```typescript
+ * import { DispatchTickets } from '@dispatchtickets/sdk';
+ *
+ * const client = new DispatchTickets({
+ *   apiKey: 'sk_live_...',
+ * });
+ *
+ * // List brands
+ * const brands = await client.brands.list();
+ *
+ * // Create a ticket
+ * const ticket = await client.tickets.create('ws_abc123', {
+ *   title: 'Help with login',
+ *   body: 'I cannot log in to my account',
+ * });
+ *
+ * // Iterate through all tickets
+ * for await (const ticket of client.tickets.list('ws_abc123', { status: 'open' })) {
+ *   console.log(ticket.title);
+ * }
+ * ```
+ */
+declare class DispatchTickets {
+    private readonly http;
+    /**
+     * Brands (workspaces) resource
+     */
+    readonly brands: BrandsResource;
+    /**
+     * Tickets resource
+     */
+    readonly tickets: TicketsResource;
+    /**
+     * Comments resource
+     */
+    readonly comments: CommentsResource;
+    /**
+     * Attachments resource
+     */
+    readonly attachments: AttachmentsResource;
+    /**
+     * Webhooks resource
+     */
+    readonly webhooks: WebhooksResource;
+    /**
+     * Categories resource
+     */
+    readonly categories: CategoriesResource;
+    /**
+     * Tags resource
+     */
+    readonly tags: TagsResource;
+    /**
+     * Customers resource
+     */
+    readonly customers: CustomersResource;
+    /**
+     * Custom fields resource
+     */
+    readonly fields: FieldsResource;
+    /**
+     * Static webhook utilities
+     */
+    static readonly webhooks: {
+        verifySignature(payload: string, signature: string, secret: string): boolean;
+        generateSignature(payload: string, secret: string): string;
+    };
+    constructor(config: DispatchTicketsConfig);
+}
+
+/**
+ * Base error class for all Dispatch Tickets SDK errors
+ */
+declare class DispatchTicketsError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: string, statusCode?: number, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when API key is missing or invalid
+ */
+declare class AuthenticationError extends DispatchTicketsError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when rate limit is exceeded
+ */
+declare class RateLimitError extends DispatchTicketsError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Thrown when request validation fails
+ */
+declare class ValidationError extends DispatchTicketsError {
+    readonly errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message?: string, errors?: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+/**
+ * Thrown when a resource is not found
+ */
+declare class NotFoundError extends DispatchTicketsError {
+    readonly resourceType?: string;
+    readonly resourceId?: string;
+    constructor(message?: string, resourceType?: string, resourceId?: string);
+}
+/**
+ * Thrown when there's a conflict (e.g., duplicate resource)
+ */
+declare class ConflictError extends DispatchTicketsError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when the server returns an unexpected error
+ */
+declare class ServerError extends DispatchTicketsError {
+    constructor(message?: string, statusCode?: number);
+}
+/**
+ * Thrown when request times out
+ */
+declare class TimeoutError extends DispatchTicketsError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when network connection fails
+ */
+declare class NetworkError extends DispatchTicketsError {
+    constructor(message?: string);
+}
+
+/**
+ * Webhook signature verification utilities
+ */
+declare const 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: string, signature: string, secret: string): boolean;
+    /**
+     * 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: string, secret: string): string;
+};
+
+/**
+ * Collect all items from an async iterable into an array
+ */
+declare function collectAll<T>(iterable: AsyncIterable<T>): Promise<T[]>;
+
+export { type Attachment, type AttachmentStatus, type AttachmentWithUrl, AuthenticationError, type AuthorType, type Brand, type BulkAction, type BulkActionResult, type Category, type CategoryStats, type Comment, type Company, ConflictError, type CreateBrandInput, type CreateCategoryInput, type CreateCommentInput, type CreateCommentOptions, type CreateCustomerInput, type CreateFieldInput, type CreateTagInput, type CreateTicketInput, type CreateTicketOptions, type CreateWebhookInput, type Customer, type DeleteBrandPreview, DispatchTickets, type DispatchTicketsConfig, DispatchTicketsError, type EntityType, type FieldDefinition, type FieldDefinitions, type FieldType, type InitiateUploadInput, type InitiateUploadResponse, type Link, type ListCustomersFilters, type ListTicketsFilters, type MergeTagsInput, type MergeTicketsInput, NetworkError, NotFoundError, type PaginatedResponse, RateLimitError, ServerError, type SortOrder, type Tag, type Ticket, type TicketPriority, type TicketSource, type TicketStatus, TimeoutError, type UpdateBrandInput, type UpdateCategoryInput, type UpdateCommentInput, type UpdateCustomerInput, type UpdateFieldInput, type UpdateTagInput, type UpdateTicketInput, ValidationError, type Webhook, type WebhookDelivery, type WebhookEvent, collectAll, webhookUtils };