@veroai/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1569 @@
+/**
+ * VeroAI SDK Types
+ */
+interface VeroAIConfig {
+    /** API key (sk_live_*, sk_test_*, or sk_dev_*) */
+    apiKey: string;
+    /** Base URL for API requests (default: https://api.veroai.dev) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retries for failed requests (default: 3) */
+    maxRetries?: number;
+    /** Custom fetch implementation (for Node.js < 18 or testing) */
+    fetch?: typeof fetch;
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    hasMore: boolean;
+    nextOffset?: number;
+}
+interface DateRangeParams {
+    startDate?: string | Date;
+    endDate?: string | Date;
+}
+type AdapterType = 'email_mx' | 'gmail-oauth' | 'sms_twilio' | 'whatsapp' | 'instagram' | 'messenger' | 'voice_twilio' | 'voice_jambonz' | 'vero-voice';
+type ChannelDirection = 'inbound' | 'outbound' | 'bidirectional';
+type ChannelStatus = 'pending' | 'active' | 'paused' | 'error' | 'suspended';
+interface Channel {
+    id: string;
+    tenantId: string;
+    name: string;
+    description: string | null;
+    adapterType: AdapterType;
+    direction: ChannelDirection;
+    status: ChannelStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateChannelParams {
+    name: string;
+    description?: string;
+    adapterType: AdapterType;
+    direction: ChannelDirection;
+    config: Record<string, unknown>;
+}
+interface UpdateChannelParams {
+    name?: string;
+    description?: string;
+    status?: 'active' | 'paused';
+    config?: Record<string, unknown>;
+}
+interface ChannelHealth {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    lastEventAt: string | null;
+    errorCount24h: number;
+    successRate: number;
+}
+type CanonicalType = 'message' | 'call' | 'status' | 'system' | 'ai';
+type EventDirection = 'inbound' | 'outbound' | 'internal';
+interface ActivityEvent {
+    eventId: string;
+    tenantId: string;
+    channelId: string;
+    eventType: string;
+    canonicalType: CanonicalType;
+    direction: EventDirection;
+    adapterType: string;
+    occurredAt: string;
+    ingestedAt: string;
+    payload: Record<string, unknown>;
+}
+interface ListEventsParams extends PaginationParams, DateRangeParams {
+    channelId?: string;
+    eventType?: string;
+    canonicalType?: CanonicalType;
+    direction?: EventDirection;
+}
+interface EventStats {
+    totalEvents: number;
+    eventsByType: Record<string, number>;
+    eventsByChannel: Record<string, number>;
+}
+interface TimeSeriesDataPoint {
+    timestamp: string;
+    value: number;
+}
+type TimeSeriesGranularity = 'minute' | 'hour' | 'day';
+interface SendMessageParams {
+    channelId: string;
+    to: string | string[];
+    subject?: string;
+    content: {
+        type: 'text' | 'html' | 'markdown';
+        text?: string;
+        html?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface SendMessageResult {
+    messageId: string;
+    eventId: string;
+    status: 'queued' | 'sent';
+    providerMessageId?: string;
+}
+type WebhookStatus = 'active' | 'paused' | 'suspended';
+interface RetryConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    backoff: 'linear' | 'exponential';
+}
+interface Webhook {
+    id: string;
+    tenantId: string;
+    name: string;
+    url: string;
+    events: string[];
+    channelId: string | null;
+    headers: Record<string, string>;
+    status: WebhookStatus;
+    retryConfig: RetryConfig;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWebhookParams {
+    name: string;
+    url: string;
+    events: string[];
+    channelId?: string | null;
+    headers?: Record<string, string>;
+    retryConfig?: Partial<RetryConfig>;
+}
+interface UpdateWebhookParams {
+    name?: string;
+    url?: string;
+    events?: string[];
+    channelId?: string | null;
+    headers?: Record<string, string>;
+    status?: 'active' | 'paused';
+    retryConfig?: Partial<RetryConfig>;
+}
+interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    eventId: string;
+    eventType?: string;
+    status: 'pending' | 'success' | 'failed';
+    attempts: number;
+    responseCode: number | null;
+    responseBody: string | null;
+    responseTimeMs: number | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+interface WebhookStats {
+    total: number;
+    success: number;
+    failed: number;
+    pending: number;
+    successRate: number;
+    averageResponseTimeMs: number;
+    timeRange: '1h' | '24h' | '7d';
+}
+type ApiKeyEnvironment = 'production' | 'development' | 'testing';
+interface ApiKey {
+    id: string;
+    tenantId: string;
+    name: string;
+    keyPrefix: string;
+    environment: ApiKeyEnvironment;
+    scopes: string[];
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+}
+interface CreateApiKeyParams {
+    name: string;
+    environment: ApiKeyEnvironment;
+    scopes: string[];
+    expiresAt?: string | Date;
+}
+interface CreateApiKeyResult {
+    apiKey: ApiKey;
+    /** The plaintext key - only returned once at creation */
+    key: string;
+}
+type DomainStatus = 'pending' | 'verified' | 'failed';
+interface Domain {
+    id: string;
+    tenantId: string;
+    domain: string;
+    status: DomainStatus;
+    verificationRecord: string | null;
+    verificationStatus: {
+        dkim: boolean;
+        spf: boolean;
+        dmarc: boolean;
+        mx: boolean;
+        lastCheckedAt?: string | null;
+    };
+    dnsRecords: DnsRecord[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface DnsRecord {
+    type: 'MX' | 'TXT' | 'CNAME';
+    name: string;
+    value: string;
+    priority?: number;
+    verified: boolean;
+}
+interface CreateDomainParams {
+    domain: string;
+    verificationMethod: 'cloudflare' | 'manual';
+    cloudflareApiToken?: string;
+}
+interface VerifyDomainResult {
+    domain: Domain;
+    verificationResults: {
+        dkim: {
+            verified: boolean;
+            error?: string;
+        };
+        spf: {
+            verified: boolean;
+            error?: string;
+        };
+        dmarc: {
+            verified: boolean;
+            error?: string;
+        };
+        mx: {
+            verified: boolean;
+            error?: string;
+        };
+    };
+}
+interface EnrichmentConfig {
+    id: string;
+    tenantId: string;
+    name: string;
+    description: string | null;
+    status: 'draft' | 'active' | 'archived';
+    intents: IntentDefinition[];
+    entities: EntityDefinition[];
+    sentiment: SentimentConfig;
+    language: LanguageConfig;
+    channelOverrides: Record<string, ChannelOverride>;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IntentDefinition {
+    id: string;
+    name: string;
+    description: string;
+    examples: string[];
+    priority: number;
+}
+interface EntityDefinition {
+    id: string;
+    name: string;
+    type: 'custom' | 'builtin';
+    extractionType: 'keyword' | 'pattern' | 'llm';
+    values?: string[];
+    pattern?: string;
+}
+interface SentimentConfig {
+    enabled: boolean;
+    includeUrgency: boolean;
+}
+interface LanguageConfig {
+    enabled: boolean;
+    supportedLanguages: string[];
+    translateToEnglish: boolean;
+}
+interface ChannelOverride {
+    intents?: string[];
+    entities?: string[];
+    sentiment?: boolean;
+    language?: boolean;
+}
+interface EnrichmentResult {
+    intent: string;
+    intentConfidence: number;
+    entities: ExtractedEntity[];
+    sentiment?: {
+        label: 'positive' | 'negative' | 'neutral';
+        score: number;
+    };
+    language?: {
+        detected: string;
+        confidence: number;
+    };
+    urgency?: 'low' | 'medium' | 'high' | 'critical';
+    processedAt: string;
+    modelVersion: string;
+}
+interface ExtractedEntity {
+    type: string;
+    value: string;
+    confidence: number;
+    position?: {
+        start: number;
+        end: number;
+    };
+}
+type PhoneNumberStatus = 'active' | 'pending' | 'released';
+type PhoneNumberCapability = 'voice' | 'sms' | 'mms';
+interface PhoneNumber {
+    id: string;
+    number: string;
+    country: string;
+    region: string | null;
+    locality: string | null;
+    capabilities: PhoneNumberCapability[];
+    channelId: string | null;
+    channelName?: string | null;
+    status: PhoneNumberStatus;
+    monthlyCostCents: number | null;
+    setupCostCents: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AvailableNumber {
+    number: string;
+    country: string;
+    region: string | null;
+    locality: string | null;
+    capabilities: PhoneNumberCapability[];
+    monthlyCostCents: number;
+    setupCostCents: number;
+    provider: string;
+}
+interface SearchNumbersParams {
+    country: string;
+    areaCode?: string;
+    contains?: string;
+    capabilities?: PhoneNumberCapability[];
+    limit?: number;
+}
+interface PurchaseNumberParams {
+    number: string;
+    channelId?: string;
+}
+interface UpdateNumberParams {
+    channelId?: string | null;
+}
+interface ListNumbersParams extends PaginationParams {
+    channelId?: string;
+    status?: PhoneNumberStatus;
+    country?: string;
+    capabilities?: PhoneNumberCapability[];
+}
+type CallDirection = 'inbound' | 'outbound';
+type CallStatus = 'initiated' | 'ringing' | 'answered' | 'ended';
+type CallEndReason = 'completed' | 'busy' | 'no-answer' | 'failed' | 'canceled';
+interface Call {
+    id: string;
+    channelId: string;
+    providerCallSid: string;
+    fromNumber: string;
+    toNumber: string;
+    direction: CallDirection;
+    status: CallStatus;
+    endReason: CallEndReason | null;
+    initiatedAt: string;
+    ringingAt: string | null;
+    answeredAt: string | null;
+    endedAt: string | null;
+    durationSeconds: number | null;
+    recordingUrl: string | null;
+    transcriptionUrl: string | null;
+    agentId: string | null;
+    metadata: Record<string, unknown> | null;
+}
+interface DialParams {
+    channelId: string;
+    to: string;
+    from?: string;
+    timeout?: number;
+    metadata?: Record<string, unknown>;
+}
+interface ListCallsParams extends PaginationParams, DateRangeParams {
+    channelId?: string;
+    direction?: CallDirection;
+    status?: CallStatus;
+    fromNumber?: string;
+    toNumber?: string;
+}
+type InboundHandler = 'agent' | 'webhook' | 'forward' | 'voicemail';
+interface TtsConfig {
+    vendor: 'elevenlabs' | 'google' | 'azure' | 'aws' | 'deepgram';
+    voice: string;
+    language?: string;
+}
+interface SttConfig {
+    vendor: 'deepgram' | 'google' | 'azure' | 'aws' | 'assembly';
+    model: string;
+    language: string;
+}
+interface RecordingConfig {
+    enabled: boolean;
+    stereo: boolean;
+}
+interface InboundConfig {
+    forwardTo?: string;
+    webhookUrl?: string;
+    voicemailGreeting?: string;
+    agentId?: string;
+}
+interface VoiceChannelConfig {
+    inboundHandler: InboundHandler;
+    inboundConfig?: InboundConfig;
+    tts?: TtsConfig;
+    stt?: SttConfig;
+    recording?: RecordingConfig;
+    transcriptionEnabled?: boolean;
+}
+interface CreateVoiceChannelParams {
+    name: string;
+    description?: string;
+    config: VoiceChannelConfig;
+}
+interface UpdateVoiceChannelParams {
+    name?: string;
+    description?: string;
+    status?: 'active' | 'paused';
+    config?: Partial<VoiceChannelConfig>;
+}
+interface CreateRoomParams {
+    /** Room name (unique identifier) */
+    name: string;
+    /** Time in seconds before empty room is deleted (default: 300) */
+    emptyTimeout?: number;
+    /** Maximum number of participants (default: 10) */
+    maxParticipants?: number;
+    /** Optional metadata to attach to the room */
+    metadata?: Record<string, unknown>;
+}
+interface JoinRoomParams {
+    /** Name of the room to join */
+    roomName: string;
+    /** Display name for the participant */
+    participantName: string;
+    /** Unique identifier for the participant (defaults to participantName) */
+    participantIdentity?: string;
+    /** Whether participant can publish audio/video (default: true) */
+    canPublish?: boolean;
+    /** Whether participant can subscribe to others (default: true) */
+    canSubscribe?: boolean;
+    /** Whether participant can send data messages (default: true) */
+    canPublishData?: boolean;
+    /** Optional metadata to attach to the participant */
+    metadata?: Record<string, unknown>;
+}
+interface LiveKitRoomInfo {
+    /** Server-assigned room ID */
+    sid: string;
+    /** Room name */
+    name: string;
+    /** WebSocket URL for client connection */
+    wsUrl: string;
+    /** Access token for joining the room */
+    token: string;
+    /** Current number of participants */
+    numParticipants: number;
+    /** Room metadata */
+    metadata?: Record<string, unknown>;
+}
+interface LiveKitRoom {
+    /** Server-assigned room ID */
+    sid: string;
+    /** Room name */
+    name: string;
+    /** Time in seconds before empty room is deleted */
+    emptyTimeout: number;
+    /** Maximum number of participants */
+    maxParticipants: number;
+    /** Room creation timestamp */
+    creationTime: string;
+    /** Current number of participants */
+    numParticipants: number;
+    /** Room metadata */
+    metadata?: string;
+}
+type ParticipantState = 'JOINING' | 'ACTIVE' | 'DISCONNECTED';
+interface LiveKitParticipant {
+    /** Server-assigned participant ID */
+    sid: string;
+    /** Participant identity */
+    identity: string;
+    /** Participant display name */
+    name: string;
+    /** Current connection state */
+    state: ParticipantState;
+    /** Participant metadata */
+    metadata?: string;
+    /** Timestamp when participant joined */
+    joinedAt: string;
+    /** Whether participant is publishing any tracks */
+    isPublisher: boolean;
+}
+interface ListRoomsParams {
+    /** Filter by room names */
+    names?: string[];
+}
+interface AgentConfig {
+    /** Agent configuration ID */
+    id: string;
+    /** Agent name */
+    name: string;
+    /** Agent description */
+    description: string | null;
+    /** Whether agent is enabled */
+    enabled: boolean;
+    /** Model configuration */
+    modelConfig: {
+        provider: 'anthropic' | 'openai';
+        modelId: string;
+        temperature: number;
+        maxTokens: number;
+    };
+    /** System prompt */
+    systemPrompt: string;
+    /** Status */
+    status: 'draft' | 'active' | 'archived';
+}
+interface ListAgentsParams extends PaginationParams {
+    /** Filter by status */
+    status?: 'draft' | 'active' | 'archived';
+    /** Filter by enabled state */
+    enabled?: boolean;
+}
+interface CreateAgentParams {
+    /** Agent name */
+    name: string;
+    /** Agent description */
+    description?: string;
+    /** Model configuration */
+    modelConfig: {
+        provider: 'anthropic' | 'openai';
+        modelId: string;
+        temperature?: number;
+        maxTokens?: number;
+    };
+    /** System prompt */
+    systemPrompt: string;
+    /** Whether to enable immediately */
+    enabled?: boolean;
+}
+interface UpdateAgentParams {
+    /** Agent name */
+    name?: string;
+    /** Agent description */
+    description?: string;
+    /** Model configuration */
+    modelConfig?: {
+        provider?: 'anthropic' | 'openai';
+        modelId?: string;
+        temperature?: number;
+        maxTokens?: number;
+    };
+    /** System prompt */
+    systemPrompt?: string;
+    /** Whether agent is enabled */
+    enabled?: boolean;
+    /** Status */
+    status?: 'draft' | 'active' | 'archived';
+}
+interface VeroAIErrorDetails {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+
+/**
+ * HTTP Client for VeroAI SDK
+ */
+
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly fetchFn;
+    constructor(config: VeroAIConfig);
+    request<T>(options: RequestOptions): Promise<T>;
+    private executeRequest;
+    private buildUrl;
+    private buildHeaders;
+    private handleErrorResponse;
+    private getRetryAfter;
+    private calculateBackoff;
+    private sleep;
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+/**
+ * Channels Resource
+ */
+
+declare class ChannelsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all channels
+     */
+    list(): Promise<PaginatedResponse<Channel>>;
+    /**
+     * Get a channel by ID
+     */
+    get(channelId: string): Promise<Channel>;
+    /**
+     * Create a new channel
+     * @returns The created channel and optionally an OAuth URL for OAuth-based adapters
+     */
+    create(params: CreateChannelParams): Promise<{
+        channel: Channel;
+        oauthUrl?: string;
+    }>;
+    /**
+     * Update a channel
+     */
+    update(channelId: string, params: UpdateChannelParams): Promise<Channel>;
+    /**
+     * Delete a channel
+     */
+    delete(channelId: string): Promise<void>;
+    /**
+     * Test channel connectivity
+     */
+    test(channelId: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Get channel health metrics
+     */
+    health(channelId: string): Promise<ChannelHealth>;
+}
+
+/**
+ * Events Resource
+ */
+
+declare class EventsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List activity events with optional filters
+     */
+    list(params?: ListEventsParams): Promise<PaginatedResponse<ActivityEvent>>;
+    /**
+     * Get a single event by ID
+     */
+    get(eventId: string): Promise<ActivityEvent>;
+    /**
+     * Get event statistics summary
+     */
+    stats(options?: {
+        days?: number;
+    }): Promise<EventStats>;
+    /**
+     * Get time series data for charts
+     */
+    timeseries(options?: {
+        days?: number;
+        granularity?: TimeSeriesGranularity;
+    }): Promise<TimeSeriesDataPoint[]>;
+}
+
+/**
+ * Messages Resource
+ */
+
+declare class MessagesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Send a message through a channel
+     *
+     * @example
+     * ```typescript
+     * // Send an SMS
+     * const result = await veroai.messages.send({
+     *   channelId: 'ch_abc123',
+     *   to: '+15551234567',
+     *   content: { type: 'text', text: 'Hello from VeroAI!' }
+     * });
+     *
+     * // Send an email
+     * const result = await veroai.messages.send({
+     *   channelId: 'ch_def456',
+     *   to: 'user@example.com',
+     *   subject: 'Welcome!',
+     *   content: {
+     *     type: 'html',
+     *     html: '<h1>Welcome to our platform</h1>'
+     *   }
+     * });
+     * ```
+     */
+    send(params: SendMessageParams): Promise<SendMessageResult>;
+    /**
+     * Send a message to multiple recipients (batch)
+     *
+     * @example
+     * ```typescript
+     * const results = await veroai.messages.sendBatch({
+     *   channelId: 'ch_abc123',
+     *   messages: [
+     *     { to: '+15551234567', content: { type: 'text', text: 'Hello!' } },
+     *     { to: '+15559876543', content: { type: 'text', text: 'Hi there!' } },
+     *   ]
+     * });
+     * ```
+     */
+    sendBatch(params: {
+        channelId: string;
+        messages: Array<{
+            to: string;
+            subject?: string;
+            content: SendMessageParams['content'];
+            metadata?: Record<string, unknown>;
+        }>;
+    }): Promise<SendMessageResult[]>;
+}
+
+/**
+ * Webhooks Resource
+ */
+
+declare class WebhooksResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all webhooks
+     */
+    list(): Promise<PaginatedResponse<Webhook>>;
+    /**
+     * Get a webhook by ID
+     */
+    get(webhookId: string): Promise<Webhook>;
+    /**
+     * Create a new webhook
+     * @returns The created webhook and the signing secret (only returned once)
+     */
+    create(params: CreateWebhookParams): Promise<{
+        webhook: Webhook;
+        secret: string;
+    }>;
+    /**
+     * Update a webhook
+     */
+    update(webhookId: string, params: UpdateWebhookParams): Promise<Webhook>;
+    /**
+     * Delete a webhook
+     */
+    delete(webhookId: string): Promise<void>;
+    /**
+     * Regenerate webhook signing secret
+     * @returns The new signing secret (only returned once)
+     */
+    regenerateSecret(webhookId: string): Promise<{
+        webhook: Webhook;
+        secret: string;
+    }>;
+    /**
+     * List delivery history for a webhook
+     */
+    deliveries(webhookId: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedResponse<WebhookDelivery> & {
+        nextCursor?: string;
+    }>;
+    /**
+     * Get webhook delivery statistics
+     */
+    stats(webhookId: string, options?: {
+        timeRange?: '1h' | '24h' | '7d';
+    }): Promise<WebhookStats>;
+}
+
+/**
+ * API Keys Resource
+ */
+
+declare class ApiKeysResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all API keys
+     */
+    list(): Promise<PaginatedResponse<ApiKey>>;
+    /**
+     * Get an API key by ID
+     */
+    get(keyId: string): Promise<ApiKey>;
+    /**
+     * Create a new API key
+     * @returns The created API key and the plaintext key (only returned once)
+     *
+     * @example
+     * ```typescript
+     * const { apiKey, key } = await veroai.apiKeys.create({
+     *   name: 'Production Key',
+     *   environment: 'production',
+     *   scopes: ['channels:read', 'channels:write', 'messages:send'],
+     * });
+     *
+     * // Save this key securely - it won't be shown again!
+     * console.log('API Key:', key); // sk_live_abc123...
+     * ```
+     */
+    create(params: CreateApiKeyParams): Promise<CreateApiKeyResult>;
+    /**
+     * Delete (revoke) an API key
+     */
+    delete(keyId: string): Promise<void>;
+    /**
+     * Alias for delete - revoke an API key
+     */
+    revoke(keyId: string): Promise<void>;
+}
+
+/**
+ * Domains Resource
+ */
+
+declare class DomainsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all domains
+     */
+    list(): Promise<PaginatedResponse<Domain>>;
+    /**
+     * Get a domain by ID
+     */
+    get(domainId: string): Promise<Domain>;
+    /**
+     * Add a new domain
+     *
+     * @example
+     * ```typescript
+     * // Manual DNS verification
+     * const { domain } = await veroai.domains.create({
+     *   domain: 'example.com',
+     *   verificationMethod: 'manual',
+     * });
+     *
+     * // Automatic via Cloudflare
+     * const { domain } = await veroai.domains.create({
+     *   domain: 'example.com',
+     *   verificationMethod: 'cloudflare',
+     *   cloudflareApiToken: 'your_cf_token',
+     * });
+     * ```
+     */
+    create(params: CreateDomainParams): Promise<{
+        domain: Domain;
+        verificationRecord?: {
+            type: string;
+            name: string;
+            value: string;
+        };
+    }>;
+    /**
+     * Delete a domain
+     */
+    delete(domainId: string): Promise<void>;
+    /**
+     * Verify domain DNS records
+     */
+    verify(domainId: string): Promise<VerifyDomainResult>;
+    /**
+     * Get DNS records that need to be configured
+     */
+    dnsRecords(domainId: string): Promise<Domain['dnsRecords']>;
+}
+
+/**
+ * Voice Numbers Resource
+ *
+ * Manages phone number operations for voice channels
+ */
+
+declare class VoiceNumbersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Search for available phone numbers to purchase
+     */
+    search(params: SearchNumbersParams): Promise<AvailableNumber[]>;
+    /**
+     * Purchase a phone number
+     */
+    purchase(params: PurchaseNumberParams): Promise<PhoneNumber>;
+    /**
+     * List owned phone numbers
+     */
+    list(params?: ListNumbersParams): Promise<PaginatedResponse<PhoneNumber>>;
+    /**
+     * Get a phone number by ID
+     */
+    get(numberId: string): Promise<PhoneNumber>;
+    /**
+     * Update a phone number (assign/unassign to channel)
+     */
+    update(numberId: string, params: UpdateNumberParams): Promise<PhoneNumber>;
+    /**
+     * Release a phone number
+     */
+    release(numberId: string): Promise<void>;
+    /**
+     * Assign a phone number to a channel
+     */
+    assignToChannel(numberId: string, channelId: string): Promise<PhoneNumber>;
+    /**
+     * Unassign a phone number from its channel
+     */
+    unassignFromChannel(numberId: string): Promise<PhoneNumber>;
+}
+
+/**
+ * Voice Calls Resource
+ *
+ * Manages voice call operations
+ */
+
+declare class VoiceCallsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Initiate an outbound call
+     */
+    dial(params: DialParams): Promise<Call>;
+    /**
+     * List calls
+     */
+    list(params?: ListCallsParams): Promise<PaginatedResponse<Call>>;
+    /**
+     * Get a call by ID
+     */
+    get(callId: string): Promise<Call>;
+    /**
+     * Hang up an active call
+     */
+    hangup(callId: string): Promise<void>;
+}
+
+/**
+ * Voice Rooms Resource
+ *
+ * LiveKit WebRTC room management for browser-based voice/video calls
+ */
+
+declare class VoiceRoomsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new WebRTC room
+     *
+     * @example
+     * ```typescript
+     * const roomInfo = await veroai.voice.rooms.create({
+     *   name: 'support-call-123',
+     *   emptyTimeout: 300,
+     *   maxParticipants: 2,
+     * });
+     * // Connect to room using roomInfo.wsUrl and roomInfo.token
+     * ```
+     */
+    create(params: CreateRoomParams): Promise<LiveKitRoomInfo>;
+    /**
+     * Join an existing room or create and join if it doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const roomInfo = await veroai.voice.rooms.join({
+     *   roomName: 'support-call-123',
+     *   participantName: 'Agent Smith',
+     * });
+     * // Use roomInfo.token to connect via LiveKit client SDK
+     * ```
+     */
+    join(params: JoinRoomParams): Promise<LiveKitRoomInfo>;
+    /**
+     * Get room details
+     *
+     * @example
+     * ```typescript
+     * const room = await veroai.voice.rooms.get('support-call-123');
+     * console.log(`Room: ${room.name}`);
+     * ```
+     */
+    get(roomName: string): Promise<LiveKitRoom>;
+    /**
+     * List all active rooms
+     *
+     * @example
+     * ```typescript
+     * const rooms = await veroai.voice.rooms.list();
+     * for (const room of rooms) {
+     *   console.log(`${room.name}`);
+     * }
+     * ```
+     */
+    list(params?: ListRoomsParams): Promise<LiveKitRoom[]>;
+    /**
+     * Delete a room and disconnect all participants
+     *
+     * @example
+     * ```typescript
+     * await veroai.voice.rooms.delete('support-call-123');
+     * ```
+     */
+    delete(roomName: string): Promise<void>;
+    /**
+     * List participants in a room
+     *
+     * @example
+     * ```typescript
+     * const participants = await veroai.voice.rooms.listParticipants('support-call-123');
+     * for (const p of participants) {
+     *   console.log(`${p.name} (${p.state})`);
+     * }
+     * ```
+     */
+    listParticipants(roomName: string): Promise<LiveKitParticipant[]>;
+    /**
+     * Remove a participant from a room
+     *
+     * @example
+     * ```typescript
+     * await veroai.voice.rooms.removeParticipant('support-call-123', 'user-456');
+     * ```
+     */
+    removeParticipant(roomName: string, identity: string): Promise<void>;
+    /**
+     * Mute or unmute a participant's audio
+     *
+     * @example
+     * ```typescript
+     * // Mute participant
+     * await veroai.voice.rooms.muteParticipant('support-call-123', 'user-456', true);
+     *
+     * // Unmute participant
+     * await veroai.voice.rooms.muteParticipant('support-call-123', 'user-456', false);
+     * ```
+     */
+    muteParticipant(roomName: string, identity: string, muted: boolean): Promise<void>;
+    /**
+     * Send a data message to participants in a room
+     *
+     * @example
+     * ```typescript
+     * // Send to all participants
+     * await veroai.voice.rooms.sendData('support-call-123', { type: 'notification', message: 'Recording started' });
+     *
+     * // Send to specific participants
+     * await veroai.voice.rooms.sendData('support-call-123', { type: 'private' }, ['user-456']);
+     * ```
+     */
+    sendData(roomName: string, data: Record<string, unknown>, destinationIdentities?: string[]): Promise<void>;
+}
+
+/**
+ * Voice Resource
+ *
+ * Combines voice numbers, calls, and rooms resources
+ */
+
+declare class VoiceResource {
+    /**
+     * Phone number management
+     */
+    readonly numbers: VoiceNumbersResource;
+    /**
+     * Call management
+     */
+    readonly calls: VoiceCallsResource;
+    /**
+     * LiveKit WebRTC room management for browser-based voice/video calls
+     */
+    readonly rooms: VoiceRoomsResource;
+    constructor(http: HttpClient);
+}
+
+/**
+ * Agents Resource
+ *
+ * Manage AI agent configurations for voice and messaging
+ */
+
+declare class AgentsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List AI agents
+     *
+     * @example
+     * ```typescript
+     * const agents = await veroai.agents.list({ status: 'active' });
+     * for (const agent of agents.data) {
+     *   console.log(`${agent.name} (${agent.modelConfig.provider})`);
+     * }
+     * ```
+     */
+    list(params?: ListAgentsParams): Promise<PaginatedResponse<AgentConfig>>;
+    /**
+     * Get an agent by ID
+     *
+     * @example
+     * ```typescript
+     * const agent = await veroai.agents.get('agent_123');
+     * console.log(`System prompt: ${agent.systemPrompt}`);
+     * ```
+     */
+    get(agentId: string): Promise<AgentConfig>;
+    /**
+     * Create a new AI agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await veroai.agents.create({
+     *   name: 'Support Agent',
+     *   modelConfig: {
+     *     provider: 'anthropic',
+     *     modelId: 'claude-3-5-sonnet-20241022',
+     *     temperature: 0.7,
+     *   },
+     *   systemPrompt: 'You are a helpful support agent...',
+     *   enabled: true,
+     * });
+     * ```
+     */
+    create(params: CreateAgentParams): Promise<AgentConfig>;
+    /**
+     * Update an agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await veroai.agents.update('agent_123', {
+     *   systemPrompt: 'Updated prompt...',
+     *   enabled: true,
+     * });
+     * ```
+     */
+    update(agentId: string, params: UpdateAgentParams): Promise<AgentConfig>;
+    /**
+     * Delete an agent
+     *
+     * @example
+     * ```typescript
+     * await veroai.agents.delete('agent_123');
+     * ```
+     */
+    delete(agentId: string): Promise<void>;
+    /**
+     * Enable an agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await veroai.agents.enable('agent_123');
+     * ```
+     */
+    enable(agentId: string): Promise<AgentConfig>;
+    /**
+     * Disable an agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await veroai.agents.disable('agent_123');
+     * ```
+     */
+    disable(agentId: string): Promise<AgentConfig>;
+}
+
+/**
+ * Realtime Types
+ *
+ * Types for WebSocket real-time event subscriptions
+ */
+/**
+ * Subscription type
+ */
+type SubscriptionType = 'event_type' | 'channel' | 'all';
+/**
+ * Subscription options
+ */
+interface SubscribeOptions {
+    /** Subscribe to specific event types */
+    eventTypes?: string[];
+    /** Subscribe to specific channel IDs */
+    channels?: string[];
+}
+/**
+ * Realtime connection state
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * Subscription confirmation from server
+ */
+interface SubscriptionConfirmation {
+    type: 'subscription_confirmed' | 'subscription_error';
+    /** The action that was confirmed (matches the 'type' field from the command) */
+    action: 'subscribe' | 'unsubscribe';
+    subscriptionType: SubscriptionType;
+    items: string[];
+    error?: string;
+}
+/**
+ * Real-time event received from WebSocket
+ */
+interface RealtimeEvent {
+    /** Event ID */
+    id: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Channel ID */
+    channelId: string;
+    /** Canonical event type */
+    canonicalType: string;
+    /** Original event type from adapter */
+    eventType: string;
+    /** Event direction */
+    direction: 'inbound' | 'outbound';
+    /** Event payload */
+    payload: Record<string, unknown>;
+    /** Enrichment data (if available) */
+    enrichment?: {
+        intent?: {
+            intent: string;
+            confidence: number;
+        };
+        sentiment?: {
+            sentiment: string;
+            score: number;
+        };
+        language?: {
+            code: string;
+            confidence: number;
+        };
+        entities?: Array<{
+            type: string;
+            value: string;
+            confidence: number;
+        }>;
+    };
+    /** Event timestamp */
+    timestamp: string;
+    /** Processing timestamp */
+    processedAt: string;
+}
+/**
+ * Event handler function
+ */
+type EventHandler = (event: RealtimeEvent) => void;
+/**
+ * Connection state change handler
+ */
+type StateChangeHandler = (state: ConnectionState) => void;
+/**
+ * Error handler
+ */
+type ErrorHandler = (error: Error) => void;
+/**
+ * Realtime configuration options
+ */
+interface RealtimeConfig {
+    /** WebSocket URL (default: wss://realtime.veroai.dev/ws) */
+    url?: string;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnect interval in ms (default: 1000, max: 30000) */
+    reconnectInterval?: number;
+    /** Max reconnection attempts (default: 10, 0 for infinite) */
+    maxReconnectAttempts?: number;
+    /** Heartbeat interval in ms (default: 30000) */
+    heartbeatInterval?: number;
+}
+/**
+ * Token fetcher function type
+ * Used to get a short-lived WebSocket token from the API
+ */
+type TokenFetcher = () => Promise<string>;
+
+/**
+ * Realtime Resource
+ *
+ * WebSocket-based real-time event subscription for the VeroAI SDK.
+ * Supports subscribing to channels, event types, or all events.
+ */
+
+declare class RealtimeResource {
+    private readonly config;
+    private readonly tokenFetcher;
+    private ws;
+    private state;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private heartbeatInterval;
+    private eventHandlers;
+    private stateHandlers;
+    private errorHandlers;
+    private activeSubscriptions;
+    private pendingSubscriptions;
+    constructor(tokenFetcher: TokenFetcher, config?: RealtimeConfig);
+    /**
+     * Get current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to all events for the tenant
+     */
+    subscribeAll(): Promise<SubscriptionConfirmation>;
+    /**
+     * Unsubscribe from all events
+     */
+    unsubscribeAll(): Promise<SubscriptionConfirmation>;
+    /**
+     * Subscribe to specific channels
+     */
+    subscribeChannels(channelIds: string[]): Promise<SubscriptionConfirmation>;
+    /**
+     * Unsubscribe from specific channels
+     */
+    unsubscribeChannels(channelIds: string[]): Promise<SubscriptionConfirmation>;
+    /**
+     * Subscribe to specific event types
+     */
+    subscribeEventTypes(eventTypes: string[]): Promise<SubscriptionConfirmation>;
+    /**
+     * Unsubscribe from specific event types
+     */
+    unsubscribeEventTypes(eventTypes: string[]): Promise<SubscriptionConfirmation>;
+    /**
+     * Subscribe to channels and/or event types
+     */
+    subscribe(options: SubscribeOptions): Promise<void>;
+    /**
+     * Unsubscribe from channels and/or event types
+     */
+    unsubscribe(options: SubscribeOptions): Promise<void>;
+    /**
+     * Add event handler
+     */
+    onEvent(handler: EventHandler): () => void;
+    /**
+     * Add connection state change handler
+     */
+    onStateChange(handler: StateChangeHandler): () => void;
+    /**
+     * Add error handler
+     */
+    onError(handler: ErrorHandler): () => void;
+    /**
+     * Remove all handlers
+     */
+    removeAllHandlers(): void;
+    private setState;
+    private emitError;
+    private emitEvent;
+    private handleMessage;
+    private sendSubscription;
+    private getSubscriptionKey;
+    private shouldReconnect;
+    private scheduleReconnect;
+    private clearReconnectTimeout;
+    private resubscribe;
+    private startHeartbeat;
+    private stopHeartbeat;
+}
+/**
+ * Factory function to create a realtime resource
+ */
+declare function createRealtimeResource(tokenFetcher: TokenFetcher, config?: RealtimeConfig): RealtimeResource;
+
+/**
+ * VeroAI SDK Client
+ *
+ * The main entry point for interacting with the VeroAI API.
+ *
+ * @example
+ * ```typescript
+ * import { VeroAI } from '@veroai/sdk';
+ *
+ * const veroai = new VeroAI({ apiKey: 'sk_live_...' });
+ *
+ * // List channels
+ * const { data: channels } = await veroai.channels.list();
+ *
+ * // Send a message
+ * const result = await veroai.messages.send({
+ *   channelId: 'ch_abc123',
+ *   to: '+15551234567',
+ *   content: { type: 'text', text: 'Hello from VeroAI!' }
+ * });
+ *
+ * // Query events
+ * const { data: events } = await veroai.events.list({
+ *   channelId: 'ch_abc123',
+ *   startDate: new Date('2024-01-01'),
+ * });
+ * ```
+ */
+
+declare class VeroAI {
+    private readonly http;
+    /** Manage communication channels (email, SMS, WhatsApp, etc.) */
+    readonly channels: ChannelsResource;
+    /** Query activity events and analytics */
+    readonly events: EventsResource;
+    /** Send messages through channels */
+    readonly messages: MessagesResource;
+    /** Manage webhook endpoints for real-time notifications */
+    readonly webhooks: WebhooksResource;
+    /** Manage API keys for authentication */
+    readonly apiKeys: ApiKeysResource;
+    /** Manage email domains for sending */
+    readonly domains: DomainsResource;
+    /** Voice phone numbers and call management */
+    readonly voice: VoiceResource;
+    /** AI agent configurations */
+    readonly agents: AgentsResource;
+    /** Real-time event subscriptions via WebSocket */
+    readonly realtime: RealtimeResource;
+    /**
+     * Create a new VeroAI client instance
+     *
+     * @param config - Configuration options
+     * @param config.apiKey - Your API key (required)
+     * @param config.baseUrl - Custom API base URL (optional)
+     * @param config.timeout - Request timeout in ms (default: 30000)
+     * @param config.maxRetries - Max retry attempts (default: 3)
+     * @param config.realtime - Realtime WebSocket configuration
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const veroai = new VeroAI({ apiKey: 'sk_live_...' });
+     *
+     * // With custom options
+     * const veroai = new VeroAI({
+     *   apiKey: 'sk_test_...',
+     *   baseUrl: 'https://api.staging.veroai.dev',
+     *   timeout: 60000,
+     *   maxRetries: 5,
+     * });
+     * ```
+     */
+    constructor(config: VeroAIConfig & {
+        realtime?: RealtimeConfig;
+    });
+    /**
+     * Create a client from environment variables
+     *
+     * Looks for VEROAI_API_KEY environment variable
+     *
+     * @example
+     * ```typescript
+     * // Reads VEROAI_API_KEY from environment
+     * const veroai = VeroAI.fromEnv();
+     * ```
+     */
+    static fromEnv(overrides?: Partial<VeroAIConfig & {
+        realtime?: RealtimeConfig;
+    }>): VeroAI;
+}
+
+/**
+ * VeroAI SDK Error Classes
+ */
+
+/**
+ * Base error class for all VeroAI SDK errors
+ */
+declare class VeroAIError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    readonly statusCode?: number;
+    constructor(message: string, code?: string, statusCode?: number, details?: Record<string, unknown>);
+    toJSON(): VeroAIErrorDetails;
+}
+/**
+ * Thrown when the API returns an error response
+ */
+declare class APIError extends VeroAIError {
+    readonly response?: Response;
+    constructor(message: string, code: string, statusCode: number, details?: Record<string, unknown>, response?: Response);
+}
+/**
+ * Thrown when authentication fails (401)
+ */
+declare class AuthenticationError extends APIError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when authorization fails (403)
+ */
+declare class AuthorizationError extends APIError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when a resource is not found (404)
+ */
+declare class NotFoundError extends APIError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when request validation fails (400)
+ */
+declare class ValidationError extends APIError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when rate limit is exceeded (429)
+ */
+declare class RateLimitError extends APIError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when the server returns an error (5xx)
+ */
+declare class ServerError extends APIError {
+    constructor(message?: string, statusCode?: number, details?: Record<string, unknown>);
+}
+/**
+ * Thrown when a request times out
+ */
+declare class TimeoutError extends VeroAIError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when there's a network connectivity issue
+ */
+declare class NetworkError extends VeroAIError {
+    constructor(message?: string, cause?: Error);
+}
+
+export { APIError, type ActivityEvent, type AdapterType, type ApiKey, type ApiKeyEnvironment, AuthenticationError, AuthorizationError, type AvailableNumber, type Call, type CallDirection, type CallEndReason, type CallStatus, type CanonicalType, type Channel, type ChannelDirection, type ChannelHealth, type ChannelOverride, type ChannelStatus, type ConnectionState, type CreateApiKeyParams, type CreateApiKeyResult, type CreateChannelParams, type CreateDomainParams, type CreateVoiceChannelParams, type CreateWebhookParams, type DateRangeParams, type DialParams, type DnsRecord, type Domain, type DomainStatus, type EnrichmentConfig, type EnrichmentResult, type EntityDefinition, type ErrorHandler, type EventDirection, type EventHandler, type EventStats, type ExtractedEntity, type InboundConfig, type InboundHandler, type IntentDefinition, type LanguageConfig, type ListCallsParams, type ListEventsParams, type ListNumbersParams, NetworkError, NotFoundError, type PaginatedResponse, type PaginationParams, type PhoneNumber, type PhoneNumberCapability, type PhoneNumberStatus, type PurchaseNumberParams, RateLimitError, type RealtimeConfig, type RealtimeEvent, RealtimeResource, type RecordingConfig, type RetryConfig, type SearchNumbersParams, type SendMessageParams, type SendMessageResult, type SentimentConfig, ServerError, type StateChangeHandler, type SttConfig, type SubscribeOptions, type SubscriptionType, type TimeSeriesDataPoint, type TimeSeriesGranularity, TimeoutError, type TtsConfig, type UpdateChannelParams, type UpdateNumberParams, type UpdateVoiceChannelParams, type UpdateWebhookParams, ValidationError, type VerifyDomainResult, VeroAI, type VeroAIConfig, VeroAIError, type VeroAIErrorDetails, VoiceCallsResource, type VoiceChannelConfig, VoiceNumbersResource, VoiceResource, type Webhook, type WebhookDelivery, type WebhookStats, type WebhookStatus, createRealtimeResource, VeroAI as default };