@delegance/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1616 @@
+import { z } from 'zod';
+
+/**
+ * Delegance SDK Types
+ */
+
+interface DeleganceClientConfig {
+    /** API key for authentication (format: dlg_xxx_sk_xxx) */
+    apiKey: string;
+    /** Base URL for the Delegance API (default: https://app.delegance.ai) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Number of retry attempts for failed requests (default: 3) */
+    retries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+}
+interface APIResponse<T = unknown> {
+    success: boolean;
+    traceId: string;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+interface PaginatedResponse<T> extends APIResponse<T[]> {
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+declare const CompanySizeSchema: z.ZodEnum<["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]>;
+type CompanySize = z.infer<typeof CompanySizeSchema>;
+declare const CreateCompanySchema: z.ZodObject<{
+    name: z.ZodString;
+    legalName: z.ZodOptional<z.ZodString>;
+    dba: z.ZodOptional<z.ZodString>;
+    industry: z.ZodString;
+    companySize: z.ZodEnum<["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]>;
+    yearEstablished: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+    fein: z.ZodOptional<z.ZodString>;
+    companyStructure: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    contactEmail: z.ZodString;
+    contactPhone: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodObject<{
+        street: z.ZodString;
+        suite: z.ZodOptional<z.ZodString>;
+        city: z.ZodString;
+        state: z.ZodString;
+        zip: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        street: string;
+        city: string;
+        state: string;
+        zip: string;
+        suite?: string | undefined;
+    }, {
+        street: string;
+        city: string;
+        state: string;
+        zip: string;
+        suite?: string | undefined;
+    }>>;
+    externalId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    industry: string;
+    companySize: "1" | "2-10" | "11-25" | "26-50" | "51-100" | "100-499" | "500+";
+    contactEmail: string;
+    legalName?: string | undefined;
+    dba?: string | undefined;
+    yearEstablished?: string | undefined;
+    website?: string | undefined;
+    fein?: string | undefined;
+    companyStructure?: string | undefined;
+    description?: string | undefined;
+    contactPhone?: string | undefined;
+    address?: {
+        street: string;
+        city: string;
+        state: string;
+        zip: string;
+        suite?: string | undefined;
+    } | undefined;
+    externalId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    industry: string;
+    companySize: "1" | "2-10" | "11-25" | "26-50" | "51-100" | "100-499" | "500+";
+    contactEmail: string;
+    legalName?: string | undefined;
+    dba?: string | undefined;
+    yearEstablished?: string | undefined;
+    website?: string | undefined;
+    fein?: string | undefined;
+    companyStructure?: string | undefined;
+    description?: string | undefined;
+    contactPhone?: string | undefined;
+    address?: {
+        street: string;
+        city: string;
+        state: string;
+        zip: string;
+        suite?: string | undefined;
+    } | undefined;
+    externalId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type CreateCompanyInput = z.infer<typeof CreateCompanySchema>;
+interface Company {
+    id: string;
+    name: string;
+    legalName?: string;
+    industry: string;
+    companySize: CompanySize;
+    contactEmail: string;
+    website?: string;
+    createdAt: string;
+}
+declare const DocumentTypeSchema: z.ZodEnum<["policy", "loss_run", "financial_statement", "sov", "application", "certificate", "endorsement", "bor", "other"]>;
+type DocumentType = z.infer<typeof DocumentTypeSchema>;
+declare const DocumentStatusSchema: z.ZodEnum<["pending", "processing", "completed", "processed", "error", "failed"]>;
+type DocumentStatus = z.infer<typeof DocumentStatusSchema>;
+interface UploadDocumentInput {
+    /** Company ID to associate the document with */
+    companyId: string;
+    /** File to upload (Buffer, Blob, or base64 string) */
+    file: Buffer | Blob | string;
+    /** File name */
+    fileName: string;
+    /** Document type for classification hint */
+    documentType?: DocumentType;
+    /** External ID for idempotency/reference */
+    externalId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface Document {
+    id: string;
+    companyId?: string;
+    fileName: string;
+    documentType?: DocumentType;
+    status: DocumentStatus;
+    fileSize: number;
+    createdAt: string;
+    updatedAt?: string;
+    externalId?: string;
+}
+interface DocumentWithExtraction extends Document {
+    extraction?: {
+        hasText: boolean;
+        textLength: number;
+        policies: ExtractedPolicy[];
+    };
+    processing?: {
+        message: string;
+        estimatedTimeSeconds: number;
+    };
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+interface ExtractedPolicy {
+    id: string;
+    policyType: string;
+    policyNumber?: string;
+    carrierName?: string;
+    effectiveDate?: string;
+    expirationDate?: string;
+    premium?: number;
+    coverageLimit?: number;
+}
+interface APIKey {
+    id: string;
+    name: string;
+    prefix: string;
+    scopes: string[];
+    isActive: boolean;
+    createdAt: string;
+    expiresAt?: string;
+    lastUsedAt?: string;
+}
+interface CreateAPIKeyInput {
+    name: string;
+    scopes?: ('read' | 'write' | 'admin')[];
+    expiresInDays?: number;
+}
+interface CreatedAPIKey extends APIKey {
+    /** The full API key - only shown once at creation time */
+    key: string;
+}
+declare class DeleganceError extends Error {
+    statusCode: number;
+    traceId?: string | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, statusCode: number, traceId?: string | undefined, details?: unknown | undefined);
+}
+declare class AuthenticationError extends DeleganceError {
+    constructor(message: string, traceId?: string);
+}
+declare class ValidationError extends DeleganceError {
+    constructor(message: string, details?: unknown, traceId?: string);
+}
+declare class NotFoundError extends DeleganceError {
+    constructor(message: string, traceId?: string);
+}
+declare class RateLimitError extends DeleganceError {
+    retryAfter?: number | undefined;
+    constructor(message: string, retryAfter?: number | undefined, traceId?: string);
+}
+
+/**
+ * HTTP Client utilities for the Delegance SDK
+ */
+
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+    /** If true, body is FormData and shouldn't be JSON stringified */
+    isFormData?: boolean;
+}
+declare const SDK_VERSION = "0.1.0";
+declare class HttpClient {
+    private config;
+    constructor(config: DeleganceClientConfig);
+    request<T>(options: RequestOptions): Promise<T>;
+    /**
+     * Upload a file with multipart form data.
+     * Retries on 5xx/network errors like request().
+     */
+    uploadFile<T>(path: string, file: Buffer | Blob, fileName: string, additionalFields?: Record<string, string>): Promise<T>;
+    /**
+     * 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).
+     */
+    private executeWithRetry;
+    private handleErrorResponse;
+    private delay;
+}
+
+/**
+ * Companies Module
+ *
+ * Handles company creation and management operations.
+ */
+
+interface ListCompaniesOptions {
+    /** Include companies created by this API key */
+    includeCreated?: boolean;
+}
+declare class CompaniesModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    create(input: CreateCompanyInput): Promise<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 });
+     * ```
+     */
+    list(options?: ListCompaniesOptions): Promise<Company[]>;
+    /**
+     * Get a company by ID
+     *
+     * @example
+     * ```typescript
+     * const company = await client.companies.get('uuid-here');
+     * ```
+     */
+    get(companyId: string): Promise<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
+     * });
+     * ```
+     */
+    upsert(input: CreateCompanyInput & {
+        externalId: string;
+    }): Promise<{
+        company: Company;
+        isExisting: boolean;
+    }>;
+}
+
+/**
+ * Documents Module
+ *
+ * Handles document upload, listing, and status operations.
+ */
+
+interface ListDocumentsResponse {
+    success: boolean;
+    documents: Document[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+    traceId: string;
+}
+interface ListDocumentsOptions {
+    /** Filter by company ID */
+    companyId?: string;
+    /** Filter by document type */
+    documentType?: DocumentType;
+    /** Filter by status */
+    status?: DocumentStatus;
+    /** Filter by external ID */
+    externalId?: string;
+    /** Maximum number of documents to return (default: 50, max: 100) */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+interface WaitForExtractionOptions {
+    /** Maximum time to wait in milliseconds (default: 120000 = 2 minutes) */
+    timeoutMs?: number;
+    /** Polling interval in milliseconds (default: 2000 = 2 seconds) */
+    pollIntervalMs?: number;
+    /** Callback for status updates */
+    onStatusChange?: (status: DocumentStatus) => void;
+}
+declare class DocumentsModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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}`);
+     * ```
+     */
+    upload(input: UploadDocumentInput): Promise<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' }
+     * ]);
+     * ```
+     */
+    uploadBatch(inputs: UploadDocumentInput[], options?: {
+        concurrency?: number;
+    }): Promise<{
+        documents: Document[];
+        errors: Array<{
+            input: UploadDocumentInput;
+            error: Error;
+        }>;
+    }>;
+    /**
+     * 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`);
+     * }
+     * ```
+     */
+    get(documentId: string): Promise<DocumentWithExtraction>;
+    /**
+     * 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 });
+     * ```
+     */
+    list(options?: ListDocumentsOptions): Promise<{
+        documents: Document[];
+        pagination: ListDocumentsResponse['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);
+     * }
+     * ```
+     */
+    waitForExtraction(documentId: string, options?: WaitForExtractionOptions): Promise<DocumentWithExtraction>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    findByExternalId(externalId: string, companyId?: string): Promise<Document | 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');
+     * ```
+     */
+    archive(documentId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Unarchive a previously archived document
+     *
+     * @example
+     * ```typescript
+     * await client.documents.unarchive('doc-uuid');
+     * console.log('Document restored');
+     * ```
+     */
+    unarchive(documentId: string): Promise<{
+        success: boolean;
+        message: string;
+        status: string;
+    }>;
+    /**
+     * 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');
+     * ```
+     */
+    reprocess(documentId: string): Promise<{
+        success: boolean;
+        message: string;
+        status: string;
+        reprocessesRemaining: number;
+    }>;
+}
+
+/**
+ * Chat Module
+ *
+ * Handles chat/LLM interactions with the Orin insurance assistant.
+ */
+
+interface ChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+interface ChatOptions {
+    /** Conversation ID for maintaining context across messages */
+    conversationId?: string;
+    /** Optional context to focus the response */
+    context?: {
+        policyId?: string;
+        documentId?: string;
+    };
+}
+interface ChatResponse {
+    success: boolean;
+    response: string;
+    conversationId: string;
+    intent?: string;
+    sources?: Array<{
+        fileName: string;
+        excerpt: string;
+    }>;
+    traceId: string;
+}
+declare class ChatModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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
+     * });
+     * ```
+     */
+    ask(message: string, options?: ChatOptions): Promise<ChatResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    startConversation(message: string): Promise<ChatResponse>;
+}
+
+/**
+ * Quotes Module
+ *
+ * Handles quote requests and carrier interactions.
+ */
+
+interface Carrier {
+    id: string;
+    name: string;
+    logoUrl?: string;
+    supportedLines?: string[];
+    statesAvailable?: string[];
+    averageQuoteTimeSeconds: number;
+    successRate?: number;
+    queueDepth: number;
+}
+interface QuoteRequest {
+    /** Carrier IDs to request quotes from */
+    carriers: string[];
+    /** Priority level */
+    priority?: 'low' | 'normal' | 'high';
+    /** Coverage types to quote (optional - uses company defaults) */
+    coverageTypes?: string[];
+    /** Schedule for later (ISO datetime) */
+    scheduledFor?: string;
+}
+interface Quote {
+    id: string;
+    carrierId: string;
+    carrierName: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    priority: string;
+    createdAt: string;
+    scheduledFor?: string;
+    startedAt?: string;
+    completedAt?: string;
+    estimatedWaitSeconds?: number | null;
+    durationSeconds?: number | null;
+    result?: {
+        premium?: number;
+        bindable?: boolean;
+        expiresAt?: string;
+    };
+    error?: string;
+    cancelledAt?: string;
+    cancelledBy?: string;
+}
+interface GetQuoteResponse {
+    success: boolean;
+    quote: Quote;
+    actions: {
+        canCancel: boolean;
+    };
+    traceId: string;
+}
+interface SubmitQuoteResponse {
+    success: boolean;
+    queueIds: string[];
+    carriers: Array<{
+        id: string;
+        name: string;
+    }>;
+    invalidCarriers?: string[];
+    errors?: string[];
+    message: string;
+    traceId: string;
+}
+interface ListQuotesResponse {
+    success: boolean;
+    quotes: Quote[];
+    count: number;
+    traceId: string;
+}
+interface ListCarriersResponse {
+    success: boolean;
+    carriers: Carrier[];
+    count: number;
+    traceId: string;
+}
+interface ListQuotesOptions {
+    /** Filter by status */
+    status?: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    /** Maximum results (default: 50) */
+    limit?: number;
+}
+declare class QuotesModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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`);
+     * }
+     * ```
+     */
+    listCarriers(): Promise<ListCarriersResponse>;
+    /**
+     * 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`);
+     * ```
+     */
+    submit(request: QuoteRequest): Promise<SubmitQuoteResponse>;
+    /**
+     * 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' });
+     * ```
+     */
+    list(options?: ListQuotesOptions): Promise<ListQuotesResponse>;
+    /**
+     * 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');
+     * }
+     * ```
+     */
+    get(quoteId: string): Promise<{
+        quote: Quote;
+        canCancel: boolean;
+    }>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    cancel(quoteId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * 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);
+     * ```
+     */
+    waitForCompletion(quoteId: string, options?: {
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<Quote>;
+}
+
+/**
+ * Policies Module
+ *
+ * Handles insurance policy management.
+ */
+
+interface Policy {
+    id: string;
+    name: string;
+    carrier: string;
+    policyNumber?: string;
+    policyType?: string;
+    premium?: number;
+    deductible?: number;
+    aggregateLimit?: number;
+    occurrenceLimit?: number;
+    effectiveDate?: string;
+    expiryDate?: string;
+    naicCode?: string;
+    amBestRating?: string;
+    sourceDocuments?: string[];
+    coverageDetails?: Record<string, unknown>;
+    exclusions?: string[];
+    endorsements?: string[];
+    additionalInsureds?: Array<{
+        name: string;
+        relationship?: string;
+    }>;
+    createdAt: string;
+    updatedAt?: string;
+    isActive: boolean;
+    daysUntilExpiry?: number | null;
+    status?: 'active' | 'expiring_soon' | 'expired';
+}
+interface PolicyCoverage {
+    id: string;
+    coverageType: string;
+    limit?: number;
+    deductible?: number;
+    description?: string;
+}
+interface GetPolicyResponse {
+    success: boolean;
+    policy: Policy;
+    coverages: PolicyCoverage[];
+    traceId: string;
+}
+interface ListPoliciesOptions {
+    /** Filter by status: active, expired, all */
+    status?: 'active' | 'expired' | 'all';
+    /** Filter policies expiring within N days */
+    expiringDays?: number;
+    /** Filter by policy type */
+    policyType?: string;
+    /** Maximum results (default: 100) */
+    limit?: number;
+}
+interface ListPoliciesResponse {
+    success: boolean;
+    policies: Policy[];
+    count: number;
+    traceId: string;
+}
+declare class PoliciesModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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 });
+     * ```
+     */
+    list(options?: ListPoliciesOptions): Promise<ListPoliciesResponse>;
+    /**
+     * Get policies expiring soon
+     *
+     * @param days - Number of days to look ahead (default: 30)
+     */
+    getExpiring(days?: number): Promise<ListPoliciesResponse>;
+    /**
+     * 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}`);
+     * ```
+     */
+    get(policyId: string): Promise<{
+        policy: Policy;
+        coverages: PolicyCoverage[];
+    } | null>;
+}
+
+/**
+ * COI (Certificate of Insurance) Module
+ *
+ * Handles COI generation and management.
+ */
+
+interface CertificateHolder {
+    name: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    email?: string;
+}
+interface GenerateCOIRequest {
+    /** Policy IDs to include in the COI */
+    policyIds: string[];
+    /** Certificate holder information */
+    certificateHolder: CertificateHolder;
+    /** Type of certificate */
+    certificateType?: 'additional_insured' | 'certificate_holder';
+    /** Description/project name */
+    description?: string;
+    /** Special provisions or endorsements */
+    specialProvisions?: string[];
+}
+interface GenerateCOIResponse {
+    success: boolean;
+    coiId: string;
+    downloadUrl: string;
+    expiresAt: string;
+    policiesIncluded: Array<{
+        id: string;
+        carrier: string;
+        policyType: string;
+    }>;
+    traceId: string;
+}
+interface COI {
+    id: string;
+    certificateHolder: string;
+    certificateType: string;
+    policyIds: string[];
+    s3Key?: string;
+    createdAt: string;
+}
+interface ListCOIsResponse {
+    success: boolean;
+    cois: COI[];
+    count: number;
+    traceId: string;
+}
+declare class COIModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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);
+     * ```
+     */
+    generate(request: GenerateCOIRequest): Promise<GenerateCOIResponse>;
+    /**
+     * List generated COIs
+     *
+     * @param limit - Maximum results (default: 50)
+     */
+    list(limit?: number): Promise<ListCOIsResponse>;
+}
+
+/**
+ * SOV (Schedule of Values) Module
+ *
+ * Handles SOV upload and management for commercial property insurance.
+ */
+
+interface UploadSOVRequest {
+    /** File buffer or Blob */
+    file: Buffer | Blob | ArrayBuffer;
+    /** Original file name */
+    fileName: string;
+    /** Line of business (default: property) */
+    lineOfBusiness?: string;
+    /** Policy effective date */
+    effectiveDate?: string;
+    /** Policy expiration date */
+    expirationDate?: string;
+}
+interface UploadSOVResponse {
+    success: boolean;
+    sovId: string;
+    s3Key: string;
+    status: string;
+    message: string;
+    traceId: string;
+}
+interface SOV {
+    id: string;
+    fileName: string;
+    status: 'uploaded' | 'parsing' | 'parsed' | 'validated' | 'submitted' | 'error';
+    lineOfBusiness: string;
+    effectiveDate?: string;
+    expirationDate?: string;
+    totalLocations?: number;
+    totalTIV?: number;
+    totalBuildingValue?: number;
+    totalContentsValue?: number;
+    totalBIValue?: number;
+    currency: string;
+    validationErrors?: string[];
+    parsingErrors?: string[];
+    createdAt: string;
+    updatedAt?: string;
+}
+interface SOVLocation {
+    id: string;
+    locationNumber: number;
+    locationName?: string;
+    address: {
+        street?: string;
+        city?: string;
+        state?: string;
+        zip?: string;
+        county?: string;
+        country?: string;
+    };
+    values: {
+        building?: number;
+        contents?: number;
+        businessIncome?: number;
+        total?: number;
+    };
+    construction: {
+        type?: string;
+        yearBuilt?: number;
+        stories?: number;
+        squareFeet?: number;
+        roofType?: string;
+    };
+    occupancy?: string;
+    protectionClass?: string;
+    sprinklered?: boolean;
+    validationIssues?: string[];
+}
+interface GetSOVResponse {
+    success: boolean;
+    sov: SOV;
+    processing?: {
+        message: string;
+        status: string;
+    };
+    locations?: {
+        items: SOVLocation[];
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    };
+    traceId: string;
+}
+interface ListSOVsResponse {
+    success: boolean;
+    sovs: SOV[];
+    count: number;
+    traceId: string;
+}
+interface ListSOVsOptions {
+    /** Filter by status */
+    status?: 'uploaded' | 'parsing' | 'parsed' | 'validated' | 'error';
+    /** Maximum results (default: 50) */
+    limit?: number;
+}
+declare class SOVModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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);
+     * ```
+     */
+    upload(request: UploadSOVRequest): Promise<UploadSOVResponse>;
+    /**
+     * List SOVs for the company
+     */
+    list(options?: ListSOVsOptions): Promise<ListSOVsResponse>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    get(sovId: string, options?: {
+        includeLocations?: boolean;
+        locationLimit?: number;
+        locationOffset?: number;
+    }): Promise<GetSOVResponse>;
+    /**
+     * Wait for SOV parsing to complete
+     */
+    waitForParsing(sovId: string, options?: {
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<SOV>;
+}
+
+/**
+ * ApiKeys Module
+ *
+ * Handles API key lifecycle management: create, list, revoke, and rotate.
+ */
+
+interface ApiKey {
+    id: string;
+    name: string;
+    prefix: string;
+    scopes: string[];
+    isActive: boolean;
+    createdAt: string;
+    expiresAt?: string;
+    lastUsedAt?: string;
+}
+/** Full API key including the secret — shown once at creation time */
+interface CreatedApiKey extends ApiKey {
+    key: string;
+}
+interface RotateResult {
+    newKey: CreatedApiKey;
+    oldKeyValidUntil: string;
+    rotationId: string;
+    status: 'rotating';
+}
+interface CreateApiKeyInput {
+    name: string;
+    scopes: ('read' | 'write' | 'admin')[];
+    expiresInDays?: number;
+}
+interface ListApiKeysOptions {
+    limit?: number;
+    cursor?: string;
+}
+interface IdempotencyOptions {
+    idempotencyKey?: string;
+}
+interface ListApiKeysResponse {
+    success: boolean;
+    data: ApiKey[];
+    pagination: {
+        cursor?: string;
+        nextCursor?: string;
+        hasMore: boolean;
+    };
+    traceId: string;
+}
+declare class ApiKeysModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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);
+     * ```
+     */
+    create(input: CreateApiKeyInput, options?: IdempotencyOptions): Promise<CreatedApiKey>;
+    /**
+     * 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 });
+     * }
+     * ```
+     */
+    list(options?: ListApiKeysOptions): Promise<{
+        data: ApiKey[];
+        pagination: ListApiKeysResponse['pagination'];
+    }>;
+    /**
+     * Revoke an API key immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.apiKeys.revoke('key-id-here');
+     * ```
+     */
+    revoke(keyId: string): Promise<void>;
+    /**
+     * 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);
+     * ```
+     */
+    rotate(keyId: string, options: {
+        gracePeriodHours: number;
+    }, idempotency?: IdempotencyOptions): Promise<RotateResult>;
+}
+
+/**
+ * Usage Module
+ *
+ * Provides access to API usage data: billing summaries, daily breakdowns,
+ * and current rate-limit status.
+ */
+
+interface MeterUsage {
+    used: number;
+    included: number;
+    overage: number;
+    overageCostCents: number;
+}
+interface UsageSummary {
+    /** Billing period, e.g. '2026-04' */
+    period: string;
+    /** Plan name, e.g. 'growth' */
+    plan: string;
+    /** Whether the period is still being estimated, has been invoiced, or is a shadow run */
+    status: 'estimated' | 'invoiced' | 'shadow';
+    /** Per-meter usage breakdown keyed by meter name */
+    meters: Record<string, MeterUsage>;
+    /** Total overage charges in cents across all meters */
+    totalOverageCents: number;
+    /** ISO-8601 timestamp of when this snapshot was computed */
+    asOf: string;
+}
+interface DailyUsage {
+    date: string;
+    meter: string;
+    quantity: number;
+}
+interface RateLimitStatus {
+    requestsPerMinute: number;
+    remaining: number;
+    /** ISO-8601 timestamp at which the rate-limit window resets */
+    resetsAt: string;
+}
+interface DailyUsageOptions {
+    /** Start date (inclusive), e.g. '2026-04-01' */
+    from: string;
+    /** End date (inclusive), e.g. '2026-04-30' */
+    to: string;
+    /** Filter to a single meter name */
+    meter?: string;
+    /** Aggregate by 'day' (default server behaviour) or 'meter' */
+    groupBy?: 'day' | 'meter';
+}
+declare class UsageModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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}`);
+     * ```
+     */
+    summary(): Promise<UsageSummary>;
+    /**
+     * 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);
+     * ```
+     */
+    daily(options: DailyUsageOptions): Promise<{
+        data: DailyUsage[];
+    }>;
+    /**
+     * 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`);
+     * ```
+     */
+    rateLimits(): Promise<RateLimitStatus>;
+}
+
+/**
+ * Knowledge Module
+ *
+ * Search notecards and document chunks, list notecards, and
+ * retrieve structured facts extracted from documents.
+ */
+
+interface KnowledgeSearchResult {
+    id: string;
+    type: 'notecard' | 'document_chunk';
+    title: string;
+    summary: string;
+    score: number;
+    documentId?: string;
+    notecardId?: string;
+    chunkId?: string;
+    highlights: string[];
+    metadata: Record<string, unknown>;
+}
+interface Notecard {
+    id: string;
+    tocPath: string;
+    templateType: string;
+    title: string;
+    summary: string;
+    content: string;
+    validFrom?: string;
+    validTo?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+interface DocumentFacts {
+    policies: Array<{
+        id: string;
+        policyType: string;
+        policyNumber?: string;
+        carrierName?: string;
+        effectiveDate?: string;
+        expirationDate?: string;
+        premium?: number;
+        coverageLimit?: number;
+    }>;
+    dates: Record<string, string>;
+    carriers: string[];
+    coverages: Array<{
+        type: string;
+        limit?: number;
+        deductible?: number;
+    }>;
+}
+interface SearchInput {
+    query: string;
+    types?: ('notecard' | 'document_chunk')[];
+    limit?: number;
+}
+interface ListNotecardsOptions {
+    type?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface KnowledgePagination {
+    cursor: string | null;
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+declare class KnowledgeModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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);
+     * ```
+     */
+    search(input: SearchInput): Promise<{
+        data: KnowledgeSearchResult[];
+        pagination: KnowledgePagination;
+    }>;
+    /**
+     * 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! });
+     * }
+     * ```
+     */
+    notecards(options?: ListNotecardsOptions): Promise<{
+        data: Notecard[];
+        pagination: KnowledgePagination;
+    }>;
+    /**
+     * 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'
+     * ```
+     */
+    documentFacts(documentId: string): Promise<DocumentFacts>;
+}
+
+/**
+ * Onboarding Module
+ *
+ * Provides a status checklist for developer onboarding: account setup,
+ * company profile completeness, billing plan, and quote readiness.
+ */
+
+/** The next recommended action for the developer to complete onboarding. */
+interface OnboardingNextStep {
+    /** Short identifier for the action, e.g. 'complete_company_profile'. */
+    action: string;
+    /** Optional list of fields that are missing or incomplete. */
+    fields?: string[];
+    /** Optional URL the developer can visit to resolve the step. */
+    url?: string;
+}
+/**
+ * Onboarding status checklist returned by `onboarding.status()`.
+ */
+interface OnboardingStatus {
+    /**
+     * Account-level setup (API key present, company exists).
+     * Always 'complete' when this endpoint returns successfully.
+     */
+    account: 'complete';
+    /**
+     * Minimum company profile (name + industry present).
+     * 'minimum' = name and industry filled in.
+     * 'complete' = all core fields populated (contact email, address, etc.).
+     */
+    company: 'minimum' | 'complete';
+    /**
+     * Full company profile completeness (all non-critical optional fields).
+     * 'incomplete' = some optional fields are missing.
+     * 'complete' = every optional field is populated.
+     */
+    companyFull: 'incomplete' | 'complete';
+    /**
+     * Current billing plan status.
+     * 'sandbox' = free developer sandbox.
+     * 'active' = paid plan in good standing.
+     * 'past_due' = payment failed, degraded access.
+     * 'cancelled' = subscription cancelled.
+     */
+    billing: 'sandbox' | 'active' | 'past_due' | 'cancelled';
+    /**
+     * Whether the company has enough information to submit a quote request.
+     * Requires at minimum: company name, industry, contact email.
+     */
+    quoteReady: boolean;
+    /**
+     * Whether the API key belongs to a sandbox (developer-trial) company.
+     */
+    sandbox: boolean;
+    /**
+     * The next recommended action, or null if onboarding is fully complete.
+     */
+    nextStep: OnboardingNextStep | null;
+}
+declare class OnboardingModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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.');
+     * }
+     * ```
+     */
+    status(): Promise<OnboardingStatus>;
+}
+
+/**
+ * Delegance SDK Client
+ *
+ * Main entry point for interacting with the Delegance API.
+ *
+ * @example
+ * ```typescript
+ * import { DeleganceClient } from '@delegance/sdk';
+ *
+ * const client = new DeleganceClient({
+ *   apiKey: 'dlg_xxx_sk_xxx',
+ *   baseUrl: 'https://app.delegance.ai'
+ * });
+ *
+ * // Create a company
+ * const company = await client.companies.create({
+ *   name: 'ABC Construction',
+ *   industry: 'construction',
+ *   companySize: '11-25',
+ *   contactEmail: 'contact@abc.com'
+ * });
+ *
+ * // Upload a document
+ * const doc = await client.documents.upload({
+ *   companyId: company.id,
+ *   file: fs.readFileSync('./policy.pdf'),
+ *   fileName: 'GL-2025.pdf'
+ * });
+ *
+ * // Wait for extraction
+ * const result = await client.documents.waitForExtraction(doc.id);
+ * ```
+ */
+
+declare class DeleganceClient {
+    private http;
+    /** Companies module for managing companies */
+    readonly companies: CompaniesModule;
+    /** Documents module for uploading and managing documents */
+    readonly documents: DocumentsModule;
+    /** Chat module for interacting with the Orin assistant */
+    readonly chat: ChatModule;
+    /** Quotes module for requesting insurance quotes */
+    readonly quotes: QuotesModule;
+    /** Policies module for managing insurance policies */
+    readonly policies: PoliciesModule;
+    /** COI module for generating certificates of insurance */
+    readonly coi: COIModule;
+    /** SOV module for managing schedules of values */
+    readonly sov: SOVModule;
+    /** API keys module for managing API keys */
+    readonly apiKeys: ApiKeysModule;
+    /** Usage module for billing summaries, daily data, and rate-limit status */
+    readonly usage: UsageModule;
+    /** Knowledge module for searching notecards and document facts */
+    readonly knowledge: KnowledgeModule;
+    /** Onboarding module for checking developer setup status */
+    readonly onboarding: OnboardingModule;
+    /**
+     * Create a new Delegance client
+     *
+     * @param config - Client configuration
+     * @throws Error if API key is missing or invalid format
+     */
+    constructor(config: DeleganceClientConfig);
+    /**
+     * Get the SDK version
+     */
+    static get version(): string;
+    /**
+     * 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');
+     * }
+     * ```
+     */
+    verifyApiKey(): Promise<boolean>;
+}
+/**
+ * Create a Delegance client from environment variables
+ *
+ * Reads from:
+ * - DELEGANCE_API_KEY - Required API key
+ * - DELEGANCE_BASE_URL - Optional base URL (default: https://app.delegance.ai)
+ *
+ * @example
+ * ```typescript
+ * // Ensure DELEGANCE_API_KEY is set in environment
+ * const client = createClientFromEnv();
+ * ```
+ */
+declare function createClientFromEnv(): DeleganceClient;
+
+export { type APIKey, type APIResponse, type ApiKey, ApiKeysModule, AuthenticationError, type COI, COIModule, type Carrier, type CertificateHolder, type ChatMessage, ChatModule, type ChatOptions, type ChatResponse, CompaniesModule, type Company, type CompanySize, CompanySizeSchema, type CreateAPIKeyInput, type CreateApiKeyInput, type CreateCompanyInput, CreateCompanySchema, type CreatedAPIKey, type CreatedApiKey, type DailyUsage, type DailyUsageOptions, DeleganceClient, type DeleganceClientConfig, DeleganceError, type Document, type DocumentFacts, type DocumentStatus, DocumentStatusSchema, type DocumentType, DocumentTypeSchema, type DocumentWithExtraction, DocumentsModule, type ExtractedPolicy, type GenerateCOIRequest, type GenerateCOIResponse, type GetPolicyResponse, type GetQuoteResponse, type GetSOVResponse, type IdempotencyOptions, KnowledgeModule, type KnowledgeSearchResult, type ListApiKeysOptions, type ListCOIsResponse, type ListCarriersResponse, type ListCompaniesOptions, type ListDocumentsOptions, type ListNotecardsOptions, type ListPoliciesOptions, type ListPoliciesResponse, type ListQuotesOptions, type ListQuotesResponse, type ListSOVsOptions, type ListSOVsResponse, type MeterUsage, NotFoundError, type Notecard, OnboardingModule, type OnboardingNextStep, type OnboardingStatus, type PaginatedResponse, PoliciesModule, type Policy, type PolicyCoverage, type Quote, type QuoteRequest, QuotesModule, RateLimitError, type RateLimitStatus, type RotateResult, SDK_VERSION, type SOV, type SOVLocation, SOVModule, type SearchInput, type SubmitQuoteResponse, type UploadDocumentInput, type UploadSOVRequest, type UploadSOVResponse, UsageModule, type UsageSummary, ValidationError, type WaitForExtractionOptions, createClientFromEnv };