@delegance/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1425 @@
+// src/types/index.ts
+import { z } from "zod";
+var CompanySizeSchema = z.enum(["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]);
+var CreateCompanySchema = z.object({
+  name: z.string().min(1).max(255),
+  legalName: z.string().max(255).optional(),
+  dba: z.string().max(255).optional(),
+  industry: z.string().min(1).max(100),
+  companySize: CompanySizeSchema,
+  yearEstablished: z.string().regex(/^\d{4}$/).optional(),
+  website: z.string().url().optional(),
+  fein: z.string().regex(/^\d{2}-\d{7}$/).optional(),
+  companyStructure: z.string().max(100).optional(),
+  description: z.string().max(2e3).optional(),
+  contactEmail: z.string().email(),
+  contactPhone: z.string().max(20).optional(),
+  address: z.object({
+    street: z.string().max(255),
+    suite: z.string().max(50).optional(),
+    city: z.string().max(100),
+    state: z.string().length(2),
+    zip: z.string().regex(/^\d{5}(-\d{4})?$/)
+  }).optional(),
+  externalId: z.string().max(255).optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var DocumentTypeSchema = z.enum([
+  "policy",
+  "loss_run",
+  "financial_statement",
+  "sov",
+  "application",
+  "certificate",
+  "endorsement",
+  "bor",
+  "other"
+]);
+var DocumentStatusSchema = z.enum([
+  "pending",
+  "processing",
+  "completed",
+  "processed",
+  "error",
+  "failed"
+]);
+var DeleganceError = class extends Error {
+  constructor(message, statusCode, traceId, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.traceId = traceId;
+    this.details = details;
+    this.name = "DeleganceError";
+  }
+};
+var AuthenticationError = class extends DeleganceError {
+  constructor(message, traceId) {
+    super(message, 401, traceId);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends DeleganceError {
+  constructor(message, details, traceId) {
+    super(message, 400, traceId, details);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends DeleganceError {
+  constructor(message, traceId) {
+    super(message, 404, traceId);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends DeleganceError {
+  constructor(message, retryAfter, traceId) {
+    super(message, 429, traceId);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+
+// src/utils/http.ts
+var SDK_VERSION = "0.1.0";
+var HttpClient = class {
+  constructor(config) {
+    this.config = {
+      baseUrl: (config.baseUrl || "https://app.delegance.ai").replace(/\/$/, ""),
+      apiKey: config.apiKey,
+      timeout: config.timeout || 3e4,
+      retries: config.retries ?? 3,
+      headers: config.headers || {}
+    };
+  }
+  async request(options) {
+    const { method, path, body, headers = {}, timeout, isFormData } = options;
+    const url = `${this.config.baseUrl}${path}`;
+    const requestHeaders = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "User-Agent": `delegance-sdk/${SDK_VERSION}`,
+      ...this.config.headers,
+      ...headers
+    };
+    if (!isFormData) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    return this.executeWithRetry(
+      () => ({
+        url,
+        init: {
+          method,
+          headers: requestHeaders,
+          body: body ? isFormData ? body : JSON.stringify(body) : void 0
+        }
+      }),
+      timeout || this.config.timeout
+    );
+  }
+  /**
+   * Upload a file with multipart form data.
+   * Retries on 5xx/network errors like request().
+   */
+  async uploadFile(path, file, fileName, additionalFields = {}) {
+    const url = `${this.config.baseUrl}${path}`;
+    const formData = new FormData();
+    if (Buffer.isBuffer(file)) {
+      const arrayBuffer = file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength);
+      formData.append("file", new Blob([arrayBuffer]), fileName);
+    } else {
+      formData.append("file", file, fileName);
+    }
+    formData.append("fileName", fileName);
+    for (const [key, value] of Object.entries(additionalFields)) {
+      formData.append(key, value);
+    }
+    const uploadHeaders = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "User-Agent": `delegance-sdk/${SDK_VERSION}`,
+      ...this.config.headers
+      // Don't set Content-Type for FormData — browser sets it with boundary
+    };
+    return this.executeWithRetry(
+      () => ({
+        url,
+        init: {
+          method: "POST",
+          headers: uploadHeaders,
+          body: formData
+        }
+      }),
+      this.config.timeout * 2
+      // Double timeout for uploads
+    );
+  }
+  /**
+   * Shared retry logic for both request() and uploadFile().
+   * Creates a fresh AbortController per attempt, clears timeout in finally,
+   * and excludes non-retryable errors (401, 400, 404, 429).
+   */
+  async executeWithRetry(buildRequest, timeoutMs) {
+    let lastError = null;
+    let attempts = 0;
+    while (attempts <= this.config.retries) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const { url, init } = buildRequest();
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        const data = await response.json().catch(() => ({}));
+        const traceId = data.traceId;
+        if (!response.ok) {
+          throw this.handleErrorResponse(response.status, data, traceId);
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof AuthenticationError || error instanceof ValidationError || error instanceof NotFoundError || error instanceof RateLimitError) {
+          throw error;
+        }
+        if (attempts < this.config.retries) {
+          attempts++;
+          await this.delay(Math.pow(2, attempts) * 1e3);
+          continue;
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw lastError || new DeleganceError("Request failed after retries", 500);
+  }
+  handleErrorResponse(status, data, traceId) {
+    const message = data.message || data.error || "Unknown error";
+    const details = data.details;
+    switch (status) {
+      case 401:
+        return new AuthenticationError(message, traceId);
+      case 400:
+        return new ValidationError(message, details, traceId);
+      case 404:
+        return new NotFoundError(message, traceId);
+      case 429:
+        return new RateLimitError(
+          message,
+          data.retryAfter,
+          traceId
+        );
+      default:
+        return new DeleganceError(message, status, traceId, details);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/modules/companies.ts
+var CompaniesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new company
+   * 
+   * @example
+   * ```typescript
+   * const company = await client.companies.create({
+   *   name: 'ABC Construction',
+   *   industry: 'construction',
+   *   companySize: '11-25',
+   *   contactEmail: 'contact@abc.com',
+   *   fein: '12-3456789'
+   * });
+   * ```
+   */
+  async create(input) {
+    const parseResult = CreateCompanySchema.safeParse(input);
+    if (!parseResult.success) {
+      throw new ValidationError(
+        "Invalid company data",
+        parseResult.error.issues
+      );
+    }
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/companies",
+      body: parseResult.data
+    });
+    return response.company;
+  }
+  /**
+   * List companies accessible to this API key
+   * 
+   * @example
+   * ```typescript
+   * const companies = await client.companies.list();
+   * 
+   * // Include companies created via this API key
+   * const allCompanies = await client.companies.list({ includeCreated: true });
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.includeCreated) {
+      params.set("includeCreated", "true");
+    }
+    const query = params.toString();
+    const path = query ? `/api/v1/companies?${query}` : "/api/v1/companies";
+    const response = await this.http.request({
+      method: "GET",
+      path
+    });
+    return response.companies;
+  }
+  /**
+   * Get a company by ID
+   * 
+   * @example
+   * ```typescript
+   * const company = await client.companies.get('uuid-here');
+   * ```
+   */
+  async get(companyId) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/companies/${companyId}`
+    });
+    return response.company;
+  }
+  /**
+   * Create a company if it doesn't exist (using externalId for deduplication)
+   * 
+   * @example
+   * ```typescript
+   * const company = await client.companies.upsert({
+   *   name: 'ABC Construction',
+   *   industry: 'construction',
+   *   companySize: '11-25',
+   *   contactEmail: 'contact@abc.com',
+   *   externalId: 'ams-12345'  // Will dedupe on this
+   * });
+   * ```
+   */
+  async upsert(input) {
+    const parseResult = CreateCompanySchema.safeParse(input);
+    if (!parseResult.success) {
+      throw new ValidationError(
+        "Invalid company data",
+        parseResult.error.issues
+      );
+    }
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/companies",
+      body: parseResult.data
+    });
+    return {
+      company: response.company,
+      isExisting: response.isExisting
+    };
+  }
+};
+
+// src/modules/documents.ts
+var DocumentsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a document for processing
+   * 
+   * @example
+   * ```typescript
+   * import fs from 'fs';
+   * 
+   * const doc = await client.documents.upload({
+   *   companyId: 'company-uuid',
+   *   file: fs.readFileSync('./policy.pdf'),
+   *   fileName: 'GL-2025.pdf',
+   *   documentType: 'policy'
+   * });
+   * 
+   * console.log(`Document ${doc.id} uploaded, status: ${doc.status}`);
+   * ```
+   */
+  async upload(input) {
+    if (!input.companyId) {
+      throw new ValidationError("companyId is required");
+    }
+    if (!input.file) {
+      throw new ValidationError("file is required");
+    }
+    if (!input.fileName) {
+      throw new ValidationError("fileName is required");
+    }
+    let fileData;
+    if (typeof input.file === "string") {
+      fileData = Buffer.from(input.file, "base64");
+    } else {
+      fileData = input.file;
+    }
+    const additionalFields = {
+      companyId: input.companyId
+    };
+    if (input.documentType) {
+      additionalFields.documentType = input.documentType;
+    }
+    if (input.externalId) {
+      additionalFields.externalId = input.externalId;
+    }
+    if (input.metadata) {
+      additionalFields.metadata = JSON.stringify(input.metadata);
+    }
+    const response = await this.http.uploadFile(
+      "/api/v1/documents",
+      fileData,
+      input.fileName,
+      additionalFields
+    );
+    return response.document;
+  }
+  /**
+   * Upload multiple documents in batch
+   * 
+   * @example
+   * ```typescript
+   * const docs = await client.documents.uploadBatch([
+   *   { companyId, file: buffer1, fileName: 'policy1.pdf' },
+   *   { companyId, file: buffer2, fileName: 'policy2.pdf' }
+   * ]);
+   * ```
+   */
+  async uploadBatch(inputs, options = {}) {
+    const concurrency = options.concurrency || 3;
+    const documents = [];
+    const errors = [];
+    for (let i = 0; i < inputs.length; i += concurrency) {
+      const batch = inputs.slice(i, i + concurrency);
+      const results = await Promise.allSettled(
+        batch.map((input) => this.upload(input))
+      );
+      for (let j = 0; j < results.length; j++) {
+        const result = results[j];
+        if (result.status === "fulfilled") {
+          documents.push(result.value);
+        } else {
+          errors.push({ input: batch[j], error: result.reason });
+        }
+      }
+    }
+    return { documents, errors };
+  }
+  /**
+   * Get document details and extraction status
+   * 
+   * @example
+   * ```typescript
+   * const doc = await client.documents.get('doc-uuid');
+   * console.log(`Status: ${doc.status}`);
+   * if (doc.extraction) {
+   *   console.log(`Found ${doc.extraction.policies.length} policies`);
+   * }
+   * ```
+   */
+  async get(documentId) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/documents/${documentId}`
+    });
+    return {
+      ...response.document,
+      extraction: response.extraction,
+      processing: response.processing,
+      error: response.error
+    };
+  }
+  /**
+   * List documents with optional filters
+   * 
+   * @example
+   * ```typescript
+   * // List all documents
+   * const docs = await client.documents.list();
+   * 
+   * // Filter by type and status
+   * const policies = await client.documents.list({
+   *   documentType: 'policy',
+   *   status: 'completed'
+   * });
+   * 
+   * // Paginate
+   * const page2 = await client.documents.list({ offset: 50, limit: 50 });
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.companyId) params.set("companyId", options.companyId);
+    if (options.documentType) params.set("documentType", options.documentType);
+    if (options.status) params.set("status", options.status);
+    if (options.externalId) params.set("externalId", options.externalId);
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const query = params.toString();
+    const path = query ? `/api/v1/documents?${query}` : "/api/v1/documents";
+    const response = await this.http.request({
+      method: "GET",
+      path
+    });
+    return {
+      documents: response.documents,
+      pagination: response.pagination
+    };
+  }
+  /**
+   * Wait for document extraction to complete
+   * 
+   * @example
+   * ```typescript
+   * const doc = await client.documents.upload({ ... });
+   * 
+   * // Wait for processing to complete
+   * const result = await client.documents.waitForExtraction(doc.id, {
+   *   timeoutMs: 60000,
+   *   onStatusChange: (status) => console.log(`Status: ${status}`)
+   * });
+   * 
+   * if (result.extraction) {
+   *   console.log('Extraction complete:', result.extraction.policies);
+   * }
+   * ```
+   */
+  async waitForExtraction(documentId, options = {}) {
+    const {
+      timeoutMs = 12e4,
+      pollIntervalMs = 2e3,
+      onStatusChange
+    } = options;
+    const startTime = Date.now();
+    let lastStatus = null;
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const doc = await this.get(documentId);
+        if (onStatusChange && doc.status !== lastStatus) {
+          onStatusChange(doc.status);
+          lastStatus = doc.status;
+        }
+        if (doc.status === "completed" || doc.status === "processed") {
+          return doc;
+        }
+        if (doc.status === "error" || doc.status === "failed") {
+          return doc;
+        }
+      } catch (error) {
+        if (error instanceof NotFoundError || error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ValidationError) {
+          throw error;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new DeleganceError(
+      `Document ${documentId} extraction did not complete within ${timeoutMs}ms (last status: ${lastStatus || "unknown"})`,
+      408
+    );
+  }
+  /**
+   * Check if a document with the given external ID already exists
+   * 
+   * @example
+   * ```typescript
+   * const existing = await client.documents.findByExternalId('ams-doc-123');
+   * if (existing) {
+   *   console.log('Document already uploaded:', existing.id);
+   * }
+   * ```
+   */
+  async findByExternalId(externalId, companyId) {
+    const params = new URLSearchParams();
+    params.set("externalId", externalId);
+    params.set("limit", "1");
+    if (companyId) params.set("companyId", companyId);
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/documents?${params.toString()}`
+    });
+    return response.documents[0] || null;
+  }
+  /**
+   * Archive a document (soft delete)
+   * 
+   * This does NOT permanently delete the document - archived documents 
+   * are excluded from list queries but remain for audit purposes.
+   * 
+   * @example
+   * ```typescript
+   * await client.documents.archive('doc-uuid');
+   * console.log('Document archived');
+   * ```
+   */
+  async archive(documentId) {
+    const response = await this.http.request({
+      method: "PATCH",
+      path: `/api/v1/documents/${documentId}`,
+      body: { action: "archive" }
+    });
+    return { success: response.success, message: response.message };
+  }
+  /**
+   * Unarchive a previously archived document
+   * 
+   * @example
+   * ```typescript
+   * await client.documents.unarchive('doc-uuid');
+   * console.log('Document restored');
+   * ```
+   */
+  async unarchive(documentId) {
+    const response = await this.http.request({
+      method: "PATCH",
+      path: `/api/v1/documents/${documentId}`,
+      body: { action: "unarchive" }
+    });
+    return { success: response.success, message: response.message, status: response.status };
+  }
+  /**
+   * Trigger re-extraction of a document
+   * 
+   * Useful when:
+   * - Document extraction failed
+   * - You want to try extraction with updated extractors
+   * - Document was partially processed
+   * 
+   * Rate limited to 3 reprocesses per document per day.
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.documents.reprocess('doc-uuid');
+   * console.log(`Reprocessing initiated. ${result.reprocessesRemaining} retries remaining today.`);
+   * 
+   * // Then wait for extraction
+   * const doc = await client.documents.waitForExtraction('doc-uuid');
+   * ```
+   */
+  async reprocess(documentId) {
+    const response = await this.http.request({
+      method: "POST",
+      path: `/api/v1/documents/${documentId}/reprocess`
+    });
+    return {
+      success: response.success,
+      message: response.message,
+      status: response.status,
+      reprocessesRemaining: response.reprocessesRemaining
+    };
+  }
+};
+
+// src/modules/chat.ts
+var ChatModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a message to the Orin insurance assistant
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.chat.ask('What is my GL coverage limit?');
+   * console.log(response.response);
+   * 
+   * // Continue the conversation
+   * const followUp = await client.chat.ask('And when does it expire?', {
+   *   conversationId: response.conversationId
+   * });
+   * ```
+   */
+  async ask(message, options = {}) {
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/chat",
+      body: {
+        message,
+        conversationId: options.conversationId,
+        context: options.context
+      }
+    });
+    return response;
+  }
+  /**
+   * Start a new conversation and send the first message
+   * 
+   * @example
+   * ```typescript
+   * const conversation = await client.chat.startConversation('Tell me about my policies');
+   * console.log('Conversation ID:', conversation.conversationId);
+   * ```
+   */
+  async startConversation(message) {
+    return this.ask(message, {
+      conversationId: crypto.randomUUID()
+    });
+  }
+};
+
+// src/modules/quotes.ts
+var QuotesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List available carriers for quoting
+   * 
+   * @example
+   * ```typescript
+   * const { carriers } = await client.quotes.listCarriers();
+   * for (const carrier of carriers) {
+   *   console.log(`${carrier.name} - avg ${carrier.averageQuoteTimeSeconds}s`);
+   * }
+   * ```
+   */
+  async listCarriers() {
+    return this.http.request({
+      method: "GET",
+      path: "/api/v1/quotes/carriers"
+    });
+  }
+  /**
+   * Submit a quote request to one or more carriers
+   * 
+   * @example
+   * ```typescript
+   * // Get available carriers
+   * const { carriers } = await client.quotes.listCarriers();
+   * 
+   * // Submit to first 3 carriers
+   * const result = await client.quotes.submit({
+   *   carriers: carriers.slice(0, 3).map(c => c.id),
+   *   priority: 'high'
+   * });
+   * 
+   * console.log(`Submitted ${result.queueIds.length} quote requests`);
+   * ```
+   */
+  async submit(request) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/quotes",
+      body: request
+    });
+  }
+  /**
+   * List quote requests for the company
+   * 
+   * @example
+   * ```typescript
+   * // List all quotes
+   * const { quotes } = await client.quotes.list();
+   * 
+   * // List only pending quotes
+   * const { quotes: pending } = await client.quotes.list({ status: 'pending' });
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    const path = query ? `/api/v1/quotes?${query}` : "/api/v1/quotes";
+    return this.http.request({
+      method: "GET",
+      path
+    });
+  }
+  /**
+   * Get a single quote by ID with full details
+   * 
+   * @example
+   * ```typescript
+   * const { quote, actions } = await client.quotes.get('quote-uuid');
+   * console.log(`Status: ${quote.status}`);
+   * if (actions.canCancel) {
+   *   console.log('This quote can be cancelled');
+   * }
+   * ```
+   */
+  async get(quoteId) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/quotes/${quoteId}`
+    });
+    return {
+      quote: response.quote,
+      canCancel: response.actions.canCancel
+    };
+  }
+  /**
+   * Cancel a pending quote
+   * 
+   * Only quotes in 'pending' status can be cancelled.
+   * Once a quote starts processing, it cannot be stopped.
+   * 
+   * @example
+   * ```typescript
+   * try {
+   *   await client.quotes.cancel('quote-uuid');
+   *   console.log('Quote cancelled');
+   * } catch (error) {
+   *   console.log('Cannot cancel:', error.message);
+   * }
+   * ```
+   */
+  async cancel(quoteId) {
+    const response = await this.http.request({
+      method: "DELETE",
+      path: `/api/v1/quotes/${quoteId}`
+    });
+    return { success: response.success, message: response.message };
+  }
+  /**
+   * Wait for a quote to complete
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.quotes.submit({ carriers: ['carrier-1'] });
+   * const quote = await client.quotes.waitForCompletion(result.queueIds[0]);
+   * console.log('Quote status:', quote.status);
+   * ```
+   */
+  async waitForCompletion(quoteId, options = {}) {
+    const { timeoutMs = 3e5, pollIntervalMs = 5e3 } = options;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const { quote } = await this.get(quoteId);
+        if (["completed", "failed", "cancelled"].includes(quote.status)) {
+          return quote;
+        }
+      } catch (error) {
+        if (error instanceof NotFoundError || error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ValidationError) {
+          throw error;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new DeleganceError(`Quote ${quoteId} did not complete within ${timeoutMs}ms`, 408);
+  }
+};
+
+// src/modules/policies.ts
+var PoliciesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List policies for the company
+   * 
+   * @example
+   * ```typescript
+   * // List all active policies
+   * const { policies } = await client.policies.list({ status: 'active' });
+   * 
+   * // List policies expiring in 30 days
+   * const { policies: expiring } = await client.policies.list({ expiringDays: 30 });
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status && options.status !== "all") params.set("status", options.status);
+    if (options.expiringDays) params.set("expiring", String(options.expiringDays));
+    if (options.policyType) params.set("type", options.policyType);
+    if (options.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    const path = query ? `/api/v1/policies?${query}` : "/api/v1/policies";
+    return this.http.request({
+      method: "GET",
+      path
+    });
+  }
+  /**
+   * Get policies expiring soon
+   * 
+   * @param days - Number of days to look ahead (default: 30)
+   */
+  async getExpiring(days = 30) {
+    return this.list({ expiringDays: days, status: "active" });
+  }
+  /**
+   * Get a single policy by ID with full details
+   * 
+   * @example
+   * ```typescript
+   * const { policy, coverages } = await client.policies.get('policy-uuid');
+   * console.log(`${policy.carrier} - ${policy.policyType}`);
+   * console.log(`Coverages: ${coverages.length}`);
+   * ```
+   */
+  async get(policyId) {
+    try {
+      const response = await this.http.request({
+        method: "GET",
+        path: `/api/v1/policies/${policyId}`
+      });
+      return {
+        policy: response.policy,
+        coverages: response.coverages || []
+      };
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/modules/coi.ts
+var COIModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Generate a Certificate of Insurance
+   * 
+   * @example
+   * ```typescript
+   * const { policies } = await client.policies.list({ status: 'active' });
+   * 
+   * const result = await client.coi.generate({
+   *   policyIds: policies.map(p => p.id),
+   *   certificateHolder: {
+   *     name: 'ABC Property Management',
+   *     address: '123 Main St',
+   *     city: 'New York',
+   *     state: 'NY',
+   *     zip: '10001'
+   *   },
+   *   certificateType: 'additional_insured'
+   * });
+   * 
+   * console.log('Download URL:', result.downloadUrl);
+   * ```
+   */
+  async generate(request) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/coi",
+      body: request
+    });
+  }
+  /**
+   * List generated COIs
+   * 
+   * @param limit - Maximum results (default: 50)
+   */
+  async list(limit = 50) {
+    return this.http.request({
+      method: "GET",
+      path: `/api/v1/coi?limit=${limit}`
+    });
+  }
+};
+
+// src/modules/sov.ts
+var SOVModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a Schedule of Values file
+   * 
+   * @example
+   * ```typescript
+   * import fs from 'fs';
+   * 
+   * const result = await client.sov.upload({
+   *   file: fs.readFileSync('./property-schedule.xlsx'),
+   *   fileName: 'property-schedule.xlsx',
+   *   lineOfBusiness: 'property',
+   *   effectiveDate: '2024-01-01'
+   * });
+   * 
+   * console.log('SOV ID:', result.sovId);
+   * ```
+   */
+  async upload(request) {
+    let fileData;
+    if (request.file instanceof ArrayBuffer) {
+      fileData = new Blob([new Uint8Array(request.file)]);
+    } else {
+      fileData = request.file;
+    }
+    const additionalFields = {};
+    if (request.lineOfBusiness) additionalFields.lineOfBusiness = request.lineOfBusiness;
+    if (request.effectiveDate) additionalFields.effectiveDate = request.effectiveDate;
+    if (request.expirationDate) additionalFields.expirationDate = request.expirationDate;
+    return this.http.uploadFile(
+      "/api/v1/sov",
+      fileData,
+      request.fileName,
+      additionalFields
+    );
+  }
+  /**
+   * List SOVs for the company
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    const path = query ? `/api/v1/sov?${query}` : "/api/v1/sov";
+    return this.http.request({
+      method: "GET",
+      path
+    });
+  }
+  /**
+   * Get a single SOV by ID with full details and locations
+   * 
+   * @example
+   * ```typescript
+   * const { sov, locations } = await client.sov.get('sov-uuid');
+   * console.log(`${sov.totalLocations} locations, TIV: $${sov.totalTIV}`);
+   * 
+   * // Access individual locations
+   * for (const loc of locations.items) {
+   *   console.log(`${loc.address.city}, ${loc.address.state}: $${loc.values.total}`);
+   * }
+   * ```
+   */
+  async get(sovId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.includeLocations !== void 0) {
+      params.set("includeLocations", String(options.includeLocations));
+    }
+    if (options.locationLimit) params.set("locationLimit", String(options.locationLimit));
+    if (options.locationOffset) params.set("locationOffset", String(options.locationOffset));
+    const query = params.toString();
+    const path = query ? `/api/v1/sov/${sovId}?${query}` : `/api/v1/sov/${sovId}`;
+    return this.http.request({
+      method: "GET",
+      path
+    });
+  }
+  /**
+   * Wait for SOV parsing to complete
+   */
+  async waitForParsing(sovId, options = {}) {
+    const { timeoutMs = 12e4, pollIntervalMs = 3e3 } = options;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const { sov } = await this.get(sovId, { includeLocations: false });
+        if (["parsed", "validated", "submitted", "error"].includes(sov.status)) {
+          return sov;
+        }
+      } catch (error) {
+        if (error instanceof NotFoundError || error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof ValidationError) {
+          throw error;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new DeleganceError(`SOV ${sovId} did not complete parsing within ${timeoutMs}ms`, 408);
+  }
+};
+
+// src/modules/api-keys.ts
+var ApiKeysModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new API key.
+   *
+   * The returned `key` value (the full secret) is shown **only once**.
+   * Store it securely — it cannot be retrieved again.
+   *
+   * @example
+   * ```typescript
+   * const created = await client.apiKeys.create({
+   *   name: 'My Integration Key',
+   *   scopes: ['read', 'write'],
+   *   expiresInDays: 365,
+   * });
+   * console.log('Save this key now:', created.key);
+   * ```
+   */
+  async create(input, options) {
+    if (!input.name || !input.name.trim()) {
+      throw new ValidationError("API key name is required and cannot be blank");
+    }
+    const body = {
+      name: input.name,
+      scopes: input.scopes
+    };
+    if (input.expiresInDays !== void 0) {
+      body.expiresInDays = input.expiresInDays;
+    }
+    const requestOptions = {
+      method: "POST",
+      path: "/api/v1/api-keys",
+      body
+    };
+    if (options?.idempotencyKey) {
+      requestOptions.headers = { "Idempotency-Key": options.idempotencyKey };
+    }
+    const response = await this.http.request(requestOptions);
+    return response.data;
+  }
+  /**
+   * List API keys for the current workspace.
+   *
+   * @example
+   * ```typescript
+   * const { data, pagination } = await client.apiKeys.list({ limit: 20 });
+   * if (pagination.hasMore) {
+   *   const next = await client.apiKeys.list({ cursor: pagination.nextCursor });
+   * }
+   * ```
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    if (options.cursor !== void 0) {
+      params.set("cursor", options.cursor);
+    }
+    const query = params.toString();
+    const path = query ? `/api/v1/api-keys?${query}` : "/api/v1/api-keys";
+    const response = await this.http.request({
+      method: "GET",
+      path
+    });
+    return {
+      data: response.data,
+      pagination: response.pagination
+    };
+  }
+  /**
+   * Revoke an API key immediately.
+   *
+   * @example
+   * ```typescript
+   * await client.apiKeys.revoke('key-id-here');
+   * ```
+   */
+  async revoke(keyId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/api/v1/api-keys/${keyId}`
+    });
+  }
+  /**
+   * Rotate an API key.
+   *
+   * Issues a new key while keeping the old key valid for `gracePeriodHours`
+   * so you have time to update your integrations.
+   *
+   * @example
+   * ```typescript
+   * const { newKey, oldKeyValidUntil } = await client.apiKeys.rotate(
+   *   'key-id-here',
+   *   { gracePeriodHours: 24 },
+   *   { idempotencyKey: 'my-rotation-id' }
+   * );
+   * console.log('New key (save now):', newKey.key);
+   * console.log('Old key expires:', oldKeyValidUntil);
+   * ```
+   */
+  async rotate(keyId, options, idempotency) {
+    const requestOptions = {
+      method: "POST",
+      path: `/api/v1/api-keys/${keyId}/rotate`,
+      body: { gracePeriodHours: options.gracePeriodHours }
+    };
+    if (idempotency?.idempotencyKey) {
+      requestOptions.headers = { "Idempotency-Key": idempotency.idempotencyKey };
+    }
+    const response = await this.http.request(requestOptions);
+    return response.data;
+  }
+};
+
+// src/modules/usage.ts
+var UsageModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a billing-period summary across all meters.
+   *
+   * @example
+   * ```typescript
+   * const summary = await client.usage.summary();
+   * console.log(`Plan: ${summary.plan}, overage: $${summary.totalOverageCents / 100}`);
+   * ```
+   */
+  async summary() {
+    const response = await this.http.request({
+      method: "GET",
+      path: "/api/v1/usage/summary"
+    });
+    return response.data;
+  }
+  /**
+   * Get daily usage data for a date range.
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.usage.daily({
+   *   from: '2026-04-01',
+   *   to: '2026-04-30',
+   *   meter: 'api_requests',
+   * });
+   * const total = data.reduce((sum, row) => sum + row.quantity, 0);
+   * ```
+   */
+  async daily(options) {
+    if (!options.from) {
+      throw new ValidationError('daily() requires a non-empty "from" date');
+    }
+    if (!options.to) {
+      throw new ValidationError('daily() requires a non-empty "to" date');
+    }
+    const params = new URLSearchParams();
+    params.set("from", options.from);
+    params.set("to", options.to);
+    if (options.meter !== void 0) {
+      params.set("meter", options.meter);
+    }
+    if (options.groupBy !== void 0) {
+      params.set("groupBy", options.groupBy);
+    }
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/usage/daily?${params.toString()}`
+    });
+    return { data: response.data };
+  }
+  /**
+   * Get the current rate-limit status for this API key.
+   *
+   * @example
+   * ```typescript
+   * const limits = await client.usage.rateLimits();
+   * console.log(`${limits.remaining}/${limits.requestsPerMinute} requests remaining`);
+   * ```
+   */
+  async rateLimits() {
+    const response = await this.http.request({
+      method: "GET",
+      path: "/api/v1/usage/rate-limits"
+    });
+    return response.data;
+  }
+};
+
+// src/modules/knowledge.ts
+var KnowledgeModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Search notecards and document chunks using semantic search.
+   *
+   * Uses POST because the query body can be complex (filters, types, etc.).
+   *
+   * @example
+   * ```typescript
+   * const { data, pagination } = await client.knowledge.search({
+   *   query: 'general liability occurrence limit',
+   *   types: ['notecard'],
+   *   limit: 10,
+   * });
+   * console.log(data[0].title, data[0].score);
+   * ```
+   */
+  async search(input) {
+    if (!input.query || !input.query.trim()) {
+      throw new ValidationError("search query must be a non-empty string");
+    }
+    const body = { query: input.query };
+    if (input.types !== void 0) body.types = input.types;
+    if (input.limit !== void 0) body.limit = input.limit;
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/knowledge/search",
+      body
+    });
+    return { data: response.data, pagination: response.pagination };
+  }
+  /**
+   * List notecards, optionally filtered by template type.
+   *
+   * @example
+   * ```typescript
+   * const { data, pagination } = await client.knowledge.notecards({
+   *   type: 'policy_summary',
+   *   limit: 50,
+   * });
+   * if (pagination.hasMore) {
+   *   const next = await client.knowledge.notecards({ cursor: pagination.nextCursor! });
+   * }
+   * ```
+   */
+  async notecards(options = {}) {
+    const params = new URLSearchParams();
+    if (options.type) params.set("type", options.type);
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.cursor) params.set("cursor", options.cursor);
+    const query = params.toString();
+    const path = query ? `/api/v1/knowledge/notecards?${query}` : "/api/v1/knowledge/notecards";
+    const response = await this.http.request({
+      method: "GET",
+      path
+    });
+    return { data: response.data, pagination: response.pagination };
+  }
+  /**
+   * Retrieve structured facts extracted from a document.
+   *
+   * @throws {NotFoundError} when the document does not exist
+   *
+   * @example
+   * ```typescript
+   * const facts = await client.knowledge.documentFacts('doc-uuid');
+   * console.log(facts.carriers);          // ['Hartford', 'Chubb']
+   * console.log(facts.policies[0].policyType); // 'GL'
+   * ```
+   */
+  async documentFacts(documentId) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/knowledge/documents/${documentId}/facts`
+    });
+    return response.data;
+  }
+};
+
+// src/modules/onboarding.ts
+var OnboardingModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Retrieve the onboarding status checklist for the authenticated company.
+   *
+   * Use this to determine what setup steps remain before going live.
+   *
+   * @example
+   * ```typescript
+   * const status = await client.onboarding.status();
+   *
+   * if (!status.quoteReady) {
+   *   console.log('Next step:', status.nextStep?.action);
+   * }
+   *
+   * if (status.sandbox) {
+   *   console.log('Running in sandbox mode — upgrade to submit live quotes.');
+   * }
+   * ```
+   */
+  async status() {
+    const response = await this.http.request({
+      method: "GET",
+      path: "/api/v1/onboarding/status"
+    });
+    return response.data;
+  }
+};
+
+// src/client.ts
+var API_KEY_REGEX = /^dlg_[a-zA-Z0-9]{8}_sk_[a-zA-Z0-9]{32}$/;
+var DeleganceClient = class {
+  /**
+   * Create a new Delegance client
+   * 
+   * @param config - Client configuration
+   * @throws Error if API key is missing or invalid format
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required. Get one from the Delegance dashboard.");
+    }
+    if (!API_KEY_REGEX.test(config.apiKey)) {
+      throw new Error(
+        "Invalid API key format. Expected format: dlg_xxxxxxxx_sk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      );
+    }
+    this.http = new HttpClient(config);
+    this.companies = new CompaniesModule(this.http);
+    this.documents = new DocumentsModule(this.http);
+    this.chat = new ChatModule(this.http);
+    this.quotes = new QuotesModule(this.http);
+    this.policies = new PoliciesModule(this.http);
+    this.coi = new COIModule(this.http);
+    this.sov = new SOVModule(this.http);
+    this.apiKeys = new ApiKeysModule(this.http);
+    this.usage = new UsageModule(this.http);
+    this.knowledge = new KnowledgeModule(this.http);
+    this.onboarding = new OnboardingModule(this.http);
+  }
+  /**
+   * Get the SDK version
+   */
+  static get version() {
+    return SDK_VERSION;
+  }
+  /**
+   * Verify the API key is valid by making a test request
+   * 
+   * @example
+   * ```typescript
+   * const isValid = await client.verifyApiKey();
+   * if (!isValid) {
+   *   console.error('API key is invalid or expired');
+   * }
+   * ```
+   */
+  async verifyApiKey() {
+    try {
+      await this.companies.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createClientFromEnv() {
+  const apiKey = process.env.DELEGANCE_API_KEY;
+  const baseUrl = process.env.DELEGANCE_BASE_URL;
+  if (!apiKey) {
+    throw new Error(
+      "DELEGANCE_API_KEY environment variable is required. Get an API key from the Delegance dashboard."
+    );
+  }
+  return new DeleganceClient({
+    apiKey,
+    baseUrl
+  });
+}
+export {
+  ApiKeysModule,
+  AuthenticationError,
+  COIModule,
+  ChatModule,
+  CompaniesModule,
+  CompanySizeSchema,
+  CreateCompanySchema,
+  DeleganceClient,
+  DeleganceError,
+  DocumentStatusSchema,
+  DocumentTypeSchema,
+  DocumentsModule,
+  KnowledgeModule,
+  NotFoundError,
+  OnboardingModule,
+  PoliciesModule,
+  QuotesModule,
+  RateLimitError,
+  SDK_VERSION,
+  SOVModule,
+  UsageModule,
+  ValidationError,
+  createClientFromEnv
+};