nixflex 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,704 @@
+interface NixflexClientOptions {
+    /** Your full API key: "nxf_xxx:nxfs_xxx" (key_id:key_secret). */
+    apiKey: string;
+    /** Override the API base URL (testing/staging). Default: https://api.nixflex.com */
+    baseUrl?: string;
+    /** Per-request timeout in milliseconds. Default 30000. */
+    timeoutMs?: number;
+    /** Max automatic retries for retryable failures. Default 1. Set 0 to disable. */
+    maxRetries?: number;
+}
+interface RequestOptions {
+    /** Override the client timeout for this one request. */
+    timeoutMs?: number;
+    /** AbortSignal to cancel the request from outside. */
+    signal?: AbortSignal;
+}
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    constructor(opts: NixflexClientOptions);
+    request<T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>, reqOpts?: RequestOptions): Promise<T>;
+    private fetchWithTimeout;
+}
+
+type ResponseLength = 'short' | 'medium' | 'long';
+type TransferType = 'cold' | 'warm';
+/** Parameters for creating an agent. Every field is optional - the API has
+ * sensible defaults for all of them. `name` is the only one recommended. */
+interface AgentCreateParams {
+    /** Display name (max 100 chars). Default "Untitled Agent". */
+    name?: string;
+    /** The AI's instructions (max 16000 chars ~ 4000 tokens). Over-limit is rejected with `prompt_too_long`. */
+    system_prompt?: string;
+    /** First line spoken on inbound calls. */
+    welcome_message?: string;
+    /** Voice name (browse in the dashboard). Default "Ashley". */
+    voice_id?: string;
+    /** Language code, or "multi" (follows the caller across 10 languages). Arabic, Hebrew, Korean, Chinese and Polish need their own code. */
+    language?: string;
+    /** Set false to disable without deleting. */
+    is_active?: boolean;
+    /** AI temperature 0-1. Default 0.3. */
+    temperature?: number;
+    response_length?: ResponseLength;
+    /** Agent greets the caller immediately. Default true. */
+    ai_speaks_first?: boolean;
+    /** AI improvises the greeting per call instead of the static welcome. */
+    dynamic_greeting?: boolean;
+    /** 0-100. Lower = harder to interrupt. Default 50. */
+    interruption_sensitivity?: number;
+    /** Milliseconds the agent waits after the caller stops speaking, 0-1000. Default 200. */
+    response_eagerness?: number;
+    /** Comma-separated words STT might mishear (staff names, treatments). Keep under 50 - too many are rejected at transcription time. */
+    boosted_keywords?: string;
+    /** Seconds the agent waits after pickup before speaking, 5-30. Default 10. */
+    pickup_delay?: number;
+    /** Hard cap on call length, 60-1800 seconds. Default 600. */
+    max_call_duration_seconds?: number;
+    /** Hang up if the caller is silent this long, 5-45 seconds. Default 30. */
+    silence_hangup_seconds?: number;
+    /** Save call audio. Recordings delete after 90 days. Default true. */
+    record_call?: boolean;
+    /** Carrier answering-machine detection: fast hangup ~4s in, NO voicemail message, extra carrier cost. OFF lets the agent detect voicemail itself and leave a message. Default false. */
+    amd_enabled?: boolean;
+    /** Keypad digits instead of speech. Three-state: true/false explicit, null = not set (a number's own setting decides). */
+    dtmf_enabled?: boolean | null;
+    /** Where to POST post-call data. */
+    webhook_url?: string | null;
+    /** Agent can end the call cleanly. Default true. */
+    func_end_call?: boolean;
+    /** Warm-transfer briefing text. Empty = AI auto-generates from the conversation. */
+    transfer_whisper?: string | null;
+    /** NOT ENFORCED - accepted and returned, but the engine does not read it. Control texting in your prompt. */
+    func_send_sms?: boolean;
+    /** NOT ENFORCED - same as func_send_sms. Transfers are controlled by your prompt and transfer_number. */
+    func_cold_transfer?: boolean;
+    transfer_type?: TransferType;
+    /** Default destination for transfers. */
+    transfer_number?: string | null;
+    /** IGNORED (legacy) - accepted for backwards compatibility, nothing reads it. Use speaking_rate. */
+    voice_speed?: number;
+    /** Speaking speed: 1 normal, 0.5 half, 1.5 fast. Clamped, not rejected. null = normal (NOT the same as 1). */
+    speaking_rate?: number | null;
+    /** Greet recognised returning callers by name. Default true. */
+    greet_by_name?: boolean;
+    /** Said when transcription fails. */
+    fallback_message?: string;
+}
+/** Update accepts any create field; omitted fields keep their values.
+ * Unrecognised field names return 200 and change NOTHING - check spelling
+ * against the docs if a setting is not taking effect. */
+type AgentUpdateParams = AgentCreateParams;
+/** The agent object as the API returns it. */
+interface Agent {
+    agent_id: string;
+    name: string;
+    system_prompt: string;
+    welcome_message: string;
+    voice_id: string;
+    language: string;
+    temperature: number;
+    response_length?: ResponseLength;
+    ai_speaks_first?: boolean;
+    dynamic_greeting?: boolean;
+    interruption_sensitivity?: number;
+    pickup_delay?: number;
+    max_call_duration_seconds: number;
+    silence_hangup_seconds: number;
+    record_call: boolean;
+    func_end_call?: boolean;
+    transfer_whisper?: string | null;
+    func_send_sms?: boolean;
+    func_cold_transfer?: boolean;
+    transfer_type?: TransferType;
+    transfer_number: string | null;
+    webhook_url: string | null;
+    voice_speed?: number;
+    speaking_rate?: number | null;
+    dtmf_enabled?: boolean | null;
+    amd_enabled?: boolean;
+    greet_by_name?: boolean;
+    fallback_message: string;
+    post_call_sms_enabled?: boolean;
+    post_call_sms_template?: string | null;
+    data_extraction_fields?: unknown[];
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface AgentDeleteResponse {
+    agent_id: string;
+    deleted: boolean;
+}
+interface ListParams {
+    /** Hard-capped at 200 per request (higher values are reduced, not rejected). */
+    limit?: number;
+    offset?: number;
+}
+
+declare class Agents {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Create an agent. Every field has a sensible default - `{ name }` alone works.
+     * The agent is immediately usable for numbers and outbound calls. */
+    create(params?: AgentCreateParams, opts?: RequestOptions): Promise<Agent>;
+    /** List active agents, newest first. Default 100, hard cap 200 per page. */
+    list(params?: ListParams, opts?: RequestOptions): Promise<Agent[]>;
+    /** Iterate ALL agents across pages: `for await (const a of client.agents.iter()) { ... }` */
+    iter(pageSize?: number, opts?: RequestOptions): AsyncGenerator<Agent>;
+    /** Fetch one agent with full configuration. Throws NixflexNotFoundError if the ID is not yours. */
+    get(agentId: string, opts?: RequestOptions): Promise<Agent>;
+    /** Update an agent. Send ONLY the fields you want to change - omitted fields
+     * keep their values. Active calls are unaffected; new calls use the new config.
+     * Unknown field names return 200 and change nothing - check spelling. */
+    update(agentId: string, params: AgentUpdateParams, opts?: RequestOptions): Promise<Agent>;
+    /** PERMANENTLY delete an agent. Attached numbers detach and stop routing;
+     * historical calls stay accessible. To disable without losing setup, use
+     * update(agentId, { is_active: false }) instead. */
+    delete(agentId: string, opts?: RequestOptions): Promise<AgentDeleteResponse>;
+}
+
+type CallDirection = 'inbound' | 'outbound';
+type CallerSentiment = 'happy' | 'neutral' | 'frustrated';
+/** A call record. Both GET /calls and GET /calls/:id return this exact shape. */
+interface Call {
+    call_id: string;
+    agent_id: string;
+    call_direction: CallDirection;
+    /** Same meaning as call_direction; both are returned. */
+    call_type?: CallDirection;
+    /** Caller's number, E.164. */
+    from_number: string;
+    /** Number that was called, E.164. */
+    to_number: string;
+    call_status: string;
+    /** Epoch MILLISECONDS. On outbound this is when dialling began - BEFORE ringing. */
+    start_timestamp: number;
+    /** Epoch MILLISECONDS. */
+    end_timestamp: number;
+    /** Epoch milliseconds when ANSWERED, or null (inbound / older calls). Ring time = answered_at - start_timestamp. */
+    answered_at: number | null;
+    /** TIME CONNECTED in ms (answer to hangup) - the number you are billed on. Ring time excluded, so on outbound this is NOT end_timestamp - start_timestamp. */
+    duration_ms: number;
+    ended_reason: string;
+    /** A single string, one turn per line - not an array of turn objects. */
+    transcript: string;
+    call_summary: string;
+    caller_sentiment: CallerSentiment;
+    call_successful: boolean;
+    /** Fields pulled from the call, per the agent's extraction settings. */
+    extracted_data: Record<string, unknown>;
+    /** Appointments booked during the call. */
+    bookings: unknown[];
+    /** MP3 link, or null if recording was off. This is the ONLY copy - the carrier's copy is deleted. */
+    recording_url: string | null;
+    recording_duration_s?: number;
+    voicemail_detected: boolean;
+    voicemail_detection_method?: string | null;
+    /** Carrier machine-detection verdict (e.g. 'human', 'machine_start'). Only when AMD is enabled. */
+    amd_result?: string | null;
+    call_reason?: string | null;
+    caller_name?: string | null;
+    /** Outbound campaign this call belongs to, or null. */
+    campaign_id?: string | null;
+    avg_latency_ms?: number;
+    /** ISO 8601 (the only non-epoch timestamp on this object). */
+    created_at: string;
+}
+/** Parameters for POST /v1/calls/outbound. */
+interface OutboundCallParams {
+    /** The agent that handles the call. Must belong to your API key. */
+    agent_id: string;
+    /** Who to call, E.164 ("+447386172392", not "07386172392"). NOTE: the field is to_number, not `to` - `to` is the SMS endpoints' field. */
+    to_number: string;
+    /** The call purpose - what to say and why. Sent fresh per call, stored nowhere. Must not be empty. */
+    prompt: string;
+    /** Key-values interpolated into the prompt as {key}. Unmatched references stay literal - check your keys. */
+    dynamic_vars?: Record<string, string>;
+    /** Which of your numbers to dial from. Must be outbound-enabled on this agent. Omit = the agent's first outbound-enabled number. */
+    from_number?: string;
+    /** Link this call to a batch campaign for reporting. */
+    campaign_id?: string;
+}
+/** Fire-and-forget: returns immediately; ringing/conversation/ending happen
+ * async. Set a webhook_url to receive call.completed when it ends. */
+interface OutboundCallResponse {
+    call_id: string;
+    status: string;
+    to: string;
+    from: string;
+}
+interface BatchRecipient {
+    phone: string;
+    /** Injected as context automatically - no {{placeholders}} needed in the prompt. */
+    variables?: Record<string, string>;
+    /** Replaces the campaign prompt for this recipient only. */
+    prompt_override?: string;
+}
+type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** Parameters for POST /v1/calls/batch. */
+interface BatchCampaignParams {
+    agent_id: string;
+    /** The call purpose for every call. Required. */
+    prompt: string;
+    /** The number to dial from - imported and attached to this agent. Twilio and Telnyx both work. */
+    from_number: string;
+    recipients: BatchRecipient[];
+    /** Display name for the campaign. */
+    name?: string;
+    /** false (default): reject the whole request on any invalid phone. true: dial valid ones, list invalid in the response. */
+    skip_invalid?: boolean;
+    /** 'now' (default, launches immediately) or 'schedule'. */
+    schedule_type?: 'now' | 'schedule';
+    /** YYYY-MM-DD. Required when schedule_type is 'schedule'. */
+    scheduled_date?: string;
+    /** Calling window start, minutes since midnight (540 = 9:00am). */
+    window_start_minutes?: number;
+    /** Calling window end, minutes since midnight (1080 = 6:00pm). Overnight windows (start > end) are supported. */
+    window_end_minutes?: number;
+    window_days?: Weekday[];
+    /** IANA timezone the window runs in (e.g. "Europe/London"). Priority: this > the agent's timezone > Europe/London. One campaign = one timezone - split multi-country lists into separate campaigns. */
+    timezone?: string;
+}
+interface BatchInvalidEntry {
+    phone: string;
+    reason: string;
+    row_index: number;
+}
+interface BatchCreateResponse {
+    campaign_id: string;
+    status: string;
+    valid_count: number;
+    invalid_count: number;
+    invalid: BatchInvalidEntry[];
+}
+interface BatchLaunchResponse {
+    campaign_id: string;
+    status: string;
+    recipients_count: number;
+    queued_count: number;
+}
+
+declare class Calls {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Trigger an outbound AI call. FIRE-AND-FORGET: returns immediately with a
+     * call_id; ringing, conversation and ending happen asynchronously. Set a
+     * webhook_url on the agent or number to receive call.completed when it ends.
+     * The dialling number must be OUTBOUND-ENABLED (inbound working does not
+     * mean outbound works - separate switches). */
+    create(params: OutboundCallParams, opts?: RequestOptions): Promise<OutboundCallResponse>;
+    /** List calls, newest first. Default 50, hard cap 200. The response is a
+     * bare array with no total - page until you get fewer rows than you asked
+     * for (or use iter()). Call data is retained 90 days. */
+    list(params?: ListParams, opts?: RequestOptions): Promise<Call[]>;
+    /** Iterate ALL calls across pages: `for await (const c of client.calls.iter()) { ... }` */
+    iter(pageSize?: number, opts?: RequestOptions): AsyncGenerator<Call>;
+    /** Fetch one call: transcript, recording URL, post-call analysis. Note:
+     * duration_ms is time CONNECTED (what you are billed on) - ring time is
+     * excluded, so it will not equal end_timestamp - start_timestamp on
+     * outbound calls. */
+    get(callId: string, opts?: RequestOptions): Promise<Call>;
+}
+
+declare class Campaigns {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Create a batch campaign - many outbound calls under one campaign_id.
+     * schedule_type 'now' launches immediately; 'schedule' waits for
+     * scheduled_date and fires INSIDE the calling window in the campaign's
+     * timezone (yours > the agent's > Europe/London). Overnight windows
+     * supported. One campaign = one timezone - split multi-country lists. */
+    create(params: BatchCampaignParams, opts?: RequestOptions): Promise<BatchCreateResponse>;
+    /** Launch a scheduled campaign immediately, overriding its schedule.
+     * Already running = no-op returning current status. */
+    launch(campaignId: string, opts?: RequestOptions): Promise<BatchLaunchResponse>;
+}
+
+/** Import params - the carrier is INFERRED from which credentials you send.
+ * Twilio: twilio_sid + twilio_token. Telnyx: telnyx_api_key + telnyx_connection_id
+ * (the ID of a TeXML Application you created in your Telnyx portal, voice webhook
+ * https://api.nixflex.com/telnyx-voice, POST, API v2, G711U on / HD Voice off). */
+interface PhoneNumberImportParams {
+    /** E.164. Must already exist in your carrier account. */
+    phone_number: string;
+    /** The agent this number answers with. Must be yours. */
+    agent_id: string;
+    /** Twilio Account SID (AC + 32 hex). Twilio import. */
+    twilio_sid?: string;
+    /** Twilio Auth Token. Twilio import. WARNING: importing REPLACES the number's existing webhooks. */
+    twilio_token?: string;
+    /** Telnyx API key with access to the number. Telnyx import. */
+    telnyx_api_key?: string;
+    /** Your TeXML Application ID. Telnyx import. */
+    telnyx_connection_id?: string;
+    /** Per-number prompt override, max 8000 chars. */
+    custom_prompt?: string;
+}
+interface PhoneNumber {
+    phone_number: string;
+    agent_id: string;
+    /** 'twilio' or 'telnyx'. */
+    provider: string;
+    /** Twilio numbers only; null on other carriers. */
+    twilio_number_sid?: string | null;
+    telnyx_number_id?: string | null;
+    inbound_enabled: boolean;
+    outbound_enabled: boolean;
+    custom_prompt?: string | null;
+    voice_id?: string | null;
+    sms_reply_enabled?: boolean;
+    sms_prompt?: string | null;
+    web_prompt?: string | null;
+    speaking_rate?: number | null;
+    dtmf_enabled?: boolean | null;
+    record_call?: boolean | null;
+    created_at?: string;
+}
+/** Every field optional - send only what changes; omitted fields are untouched.
+ * An EMPTY body is rejected. null clears a field (falls back to the agent). */
+interface PhoneNumberUpdateParams {
+    /** Business profile layered on the agent prompt for CALLS only. Max 8000. null clears. */
+    custom_prompt?: string | null;
+    /** Voice override for this number. null falls back to the agent's voice. */
+    voice_id?: string | null;
+    /** SMS agent auto-reply on/off. Default false. */
+    sms_reply_enabled?: boolean;
+    /** SMS agent instructions (independent channel). Max 20000. null clears. */
+    sms_prompt?: string | null;
+    /** Web agent instructions (independent channel). Max 20000. null clears. */
+    web_prompt?: string | null;
+    /** Speed override: 1 normal, clamped to range. null = INHERIT the agent's speed (send 1, not null, to force normal). */
+    speaking_rate?: number | null;
+    /** Keypad input: true/false explicit, null = inherit the agent's setting. */
+    dtmf_enabled?: boolean | null;
+    /** Recording: null = inherit; false stops recording this number while the agent keeps recording. */
+    record_call?: boolean | null;
+}
+interface PhoneNumberListResponse {
+    phone_numbers: PhoneNumber[];
+    count: number;
+}
+interface PhoneNumberDeleteResponse {
+    phone_number: {
+        phone_number: string;
+        deleted: boolean;
+    };
+}
+interface MonitorToggleResponse {
+    ok?: boolean;
+    phone_number: string;
+    monitor_enabled: boolean;
+}
+interface WebCallsToggleResponse {
+    ok?: boolean;
+    phone_number: string;
+    web_calls_enabled: boolean;
+}
+
+/** NOTE: this endpoint uses `to` (NOT to_number - that is the outbound-call
+ * field). Sending to_number here fails with a missing-field error. */
+interface SmsSendParams {
+    /** Agent that owns this SMS - its prompt handles any replies. */
+    agent_id: string;
+    /** Recipient, E.164. This endpoint uses `to`, not `to_number`. */
+    to: string;
+    /** Message text. 600 chars recommended for reliable delivery (carrier hard caps ~1600). */
+    message: string;
+    /** Which imported number to send from (either carrier). Omit = the agent's own number. */
+    from_number?: string;
+    /** Optional reply context: { reply_context: "..." } gives the agent background for replies to this message. */
+    context?: {
+        reply_context?: string;
+    };
+}
+interface SmsSendResponse {
+    status: string;
+    to: string;
+    from: string;
+}
+interface SmsCampaignRecipient {
+    phone: string;
+    /** Fills {{placeholders}} in the template. Missing variables render as empty strings. */
+    variables?: Record<string, string>;
+}
+/** SMS campaigns currently require a TWILIO from_number - Telnyx numbers are
+ * rejected at create (single sends via sms.send work on both carriers). */
+interface SmsCampaignCreateParams {
+    agent_id: string;
+    /** Your imported TWILIO number. */
+    from_number: string;
+    /** Display name in the dashboard. */
+    name: string;
+    /** Message text with {{variable}} placeholders. */
+    message_template: string;
+    /** Up to 10,000. */
+    recipients: SmsCampaignRecipient[];
+    schedule_type: 'now' | 'schedule';
+    /** ISO date - required when schedule_type is 'schedule'. */
+    scheduled_at?: string;
+}
+type SmsCampaignStatus = 'draft' | 'scheduled' | 'running' | 'done' | 'failed';
+interface SmsCampaign {
+    campaign_id: string;
+    agent_id: string;
+    name: string;
+    from_number?: string;
+    message_template?: string;
+    status: SmsCampaignStatus;
+    total_count: number;
+    /** Carrier-confirmed handset delivery. Note: Twilio 'sent' (handed to carrier,
+     * never confirmed) is counted as FAILED, not delivered. */
+    delivered_count: number;
+    failed_count: number;
+    pending_count: number;
+    source?: string;
+    scheduled_at?: string | null;
+    created_at: string;
+    recipients?: Array<{
+        phone: string;
+        variables?: Record<string, string>;
+        status: 'pending' | 'queued' | 'sent' | 'delivered' | 'undelivered' | 'failed';
+        twilio_sid?: string;
+        rendered_message?: string;
+        error_message?: string;
+        sent_at?: string;
+    }>;
+}
+interface SmsCampaignListResponse {
+    campaigns: SmsCampaign[];
+}
+interface SmsCampaignLaunchResponse {
+    campaign_id: string;
+    status: string;
+    total_count: number;
+    pending_count: number;
+    delivered_count: number;
+    failed_count: number;
+}
+interface SmsCampaignDeleteResponse {
+    campaign_id: string;
+    deleted: boolean;
+    /** Pending recipients that will NOT be messaged. Already-sent messages cannot be recalled. */
+    cancelled_count: number;
+}
+
+interface KeyRotateResponse {
+    message: string;
+    /** Stays the same - only the secret rotates (Stripe model). */
+    key_id: string;
+    /** Shown ONCE. The old secret stops working the instant this returns. */
+    key_secret: string;
+}
+interface KeyCreateResponse {
+    message: string;
+    key_id: string;
+    /** Shown ONCE - store it immediately. */
+    key_secret: string;
+}
+/** The REAL /v1/usage response (verified live Aug 2026 - the docs page
+ * described a different shape and is being corrected). All-time totals
+ * plus the account limits and this months concurrency peak. */
+interface Usage {
+    plan: string;
+    total_calls: number;
+    /** Fractional minutes, e.g. 551.54. */
+    total_minutes: number;
+    /** Nixflex charges only - carrier costs are billed to you by Twilio/Telnyx. */
+    total_cost: number;
+    rate_limit_per_minute: number;
+    max_concurrent: number;
+    peak_concurrent_this_month: number;
+    rejected_at_cap_this_month: number;
+}
+interface WebhookConfigResponse {
+    ok?: boolean;
+    phone_number?: string;
+    url?: string | null;
+}
+
+declare class PhoneNumbers {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Attach a number you already own. Carrier inferred from credentials
+     * (twilio_sid+twilio_token OR telnyx_api_key+telnyx_connection_id).
+     * WARNING: Twilio import REPLACES the number's existing webhooks - another
+     * system using this number stops receiving calls and SMS. */
+    import(params: PhoneNumberImportParams, opts?: RequestOptions): Promise<{
+        phone_number: PhoneNumber;
+    }>;
+    /** All numbers on your account (optionally one agent's), newest first.
+     * Not paginated - returns up to 1,000; filter by agent_id above that. */
+    list(params?: {
+        agent_id?: string;
+    }, opts?: RequestOptions): Promise<PhoneNumberListResponse>;
+    /** Update per-number settings. Send ONLY what changes (empty body is
+     * rejected). null clears/inherits - see each field's JSDoc; speaking_rate
+     * null INHERITS the agent's speed (send 1, not null, to force normal). */
+    update(phoneNumber: string, params: PhoneNumberUpdateParams, opts?: RequestOptions): Promise<{
+        phone_number: PhoneNumber;
+    }>;
+    /** Disconnect from Nixflex (clears carrier webhooks + our record). Does NOT
+     * release the number from your carrier - carrier billing continues until
+     * you release it in Twilio/Telnyx yourself. Reversible by re-importing. */
+    delete(phoneNumber: string, opts?: RequestOptions): Promise<PhoneNumberDeleteResponse>;
+    /** Turn live call monitoring on/off for a number (off by default).
+     * NOTE: enabling bills that number's inbound calls at $0.09/min. */
+    setMonitor(phoneNumber: string, enabled: boolean, opts?: RequestOptions): Promise<MonitorToggleResponse>;
+    /** Current monitoring state for a number. */
+    getMonitor(phoneNumber: string, opts?: RequestOptions): Promise<MonitorToggleResponse>;
+    /** Enable/disable browser (web) calls for a number (off by default).
+     * NOTE: enabling bills that number's calls at $0.09/min (same rule as
+     * Live Monitor - either on means 0.09, both on is still 0.09). */
+    setWebCalls(phoneNumber: string, enabled: boolean, opts?: RequestOptions): Promise<WebCallsToggleResponse>;
+    /** Current web-calls state for a number. */
+    getWebCalls(phoneNumber: string, opts?: RequestOptions): Promise<WebCallsToggleResponse>;
+}
+
+declare class SmsCampaigns {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Create a one-time SMS broadcast ({{variable}} templating per recipient,
+     * up to 10,000 recipients). Requires a TWILIO from_number - Telnyx numbers
+     * are rejected at create (single sends support both carriers). */
+    create(params: SmsCampaignCreateParams, opts?: RequestOptions): Promise<SmsCampaign>;
+    /** Launch a draft/scheduled campaign immediately. */
+    launch(campaignId: string, opts?: RequestOptions): Promise<SmsCampaignLaunchResponse>;
+    /** All campaigns, newest first, with live-computed delivery counts. */
+    list(params?: {
+        status?: SmsCampaignStatus;
+        limit?: number;
+    }, opts?: RequestOptions): Promise<SmsCampaignListResponse>;
+    /** One campaign with per-recipient statuses. Twilio 'sent' (handed to
+     * carrier, never confirmed on the handset) counts as FAILED, not delivered. */
+    get(campaignId: string, opts?: RequestOptions): Promise<SmsCampaign>;
+    /** Cancel a scheduled/running campaign. Already-sent messages cannot be
+     * recalled; cancelled_count = pending recipients that will not be messaged. */
+    delete(campaignId: string, opts?: RequestOptions): Promise<SmsCampaignDeleteResponse>;
+}
+declare class Sms {
+    private readonly http;
+    /** SMS campaigns - one-time bulk broadcasts. */
+    readonly campaigns: SmsCampaigns;
+    constructor(http: HttpClient);
+    /** Send a single SMS from one of your numbers (both carriers). NOTE: this
+     * endpoint uses `to` - NOT to_number (that is the outbound-call field).
+     * Replies are answered automatically by the agent's prompt. */
+    send(params: SmsSendParams, opts?: RequestOptions): Promise<SmsSendResponse>;
+}
+
+declare class Keys {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Rotate the key SECRET (key_id stays stable - the Stripe model). The old
+     * secret stops working THE INSTANT this returns; the new one is shown ONCE.
+     * Update every deployed app before rotating in production. */
+    rotate(opts?: RequestOptions): Promise<KeyRotateResponse>;
+}
+declare class UsageResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Usage + balance: calls, minutes, SMS, credit. minutes is fractional;
+     * cost_usd excludes carrier charges (Twilio/Telnyx bill you directly). */
+    get(opts?: RequestOptions): Promise<Usage>;
+}
+
+declare class Webhooks {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Point a number's post-call events at your HTTPS endpoint.
+     * slot 2 = the second destination (webhook2). */
+    set(phoneNumber: string, url: string, slot?: 1 | 2, opts?: RequestOptions): Promise<WebhookConfigResponse>;
+    /** Read the webhook configured on a number. */
+    get(phoneNumber: string, slot?: 1 | 2, opts?: RequestOptions): Promise<WebhookConfigResponse>;
+    /** Remove the webhook from a number. */
+    delete(phoneNumber: string, slot?: 1 | 2, opts?: RequestOptions): Promise<WebhookConfigResponse>;
+}
+
+interface NixflexAPIErrorBody {
+    error: {
+        type: string;
+        code: string;
+        message: string;
+        doc_url?: string;
+        details?: Record<string, unknown>;
+    };
+}
+declare class NixflexError extends Error {
+    /** HTTP status of the failed response (0 for network/timeout failures). */
+    readonly status: number;
+    /** Machine-readable error code, e.g. 'invalid_json', 'rate_limit_exceeded'. */
+    readonly code: string;
+    /** Error category from the API, e.g. 'invalid_request', 'rate_limit'. */
+    readonly type: string;
+    /** Link to the error's documentation page. */
+    readonly docUrl?: string;
+    /** Structured extra info the API attached to this error. */
+    readonly details: Record<string, unknown>;
+    /** The x-railway-request-id (or similar) header when present - quote it to support. */
+    readonly requestId?: string;
+    constructor(status: number, body: NixflexAPIErrorBody | null, requestId?: string, fallbackMessage?: string);
+}
+/** 401 - missing or invalid API key. */
+declare class NixflexAuthenticationError extends NixflexError {
+    constructor(...args: ConstructorParameters<typeof NixflexError>);
+}
+/** 402 - balance or credit exhausted. */
+declare class NixflexPaymentRequiredError extends NixflexError {
+    constructor(...args: ConstructorParameters<typeof NixflexError>);
+}
+/** 404 - the resource does not exist (or is not yours). */
+declare class NixflexNotFoundError extends NixflexError {
+    constructor(...args: ConstructorParameters<typeof NixflexError>);
+}
+/** 429 - rate limit hit. `retryAfterSeconds` says when to try again. */
+declare class NixflexRateLimitError extends NixflexError {
+    readonly retryAfterSeconds: number;
+    constructor(status: number, body: NixflexAPIErrorBody | null, requestId: string | undefined, retryAfterSeconds: number);
+}
+/** 400/422 - the request itself is malformed or invalid. */
+declare class NixflexInvalidRequestError extends NixflexError {
+    constructor(...args: ConstructorParameters<typeof NixflexError>);
+}
+/** 5xx - something failed on Nixflex's side. Retried automatically once. */
+declare class NixflexServerError extends NixflexError {
+    constructor(...args: ConstructorParameters<typeof NixflexError>);
+}
+/** Network failure / timeout - the request never got an HTTP response. */
+declare class NixflexConnectionError extends NixflexError {
+    constructor(message: string);
+}
+/** Map a status + body to the right error class. */
+declare function errorFromResponse(status: number, body: NixflexAPIErrorBody | null, requestId: string | undefined, retryAfterSeconds: number): NixflexError;
+
+declare class Nixflex {
+    /** AI agents - create, list, get, update, delete. */
+    readonly agents: Agents;
+    /** Calls - trigger outbound, list history, fetch transcripts + analysis. */
+    readonly calls: Calls;
+    /** Voice batch campaigns - many calls under one campaign, scheduling windows. */
+    readonly campaigns: Campaigns;
+    /** Phone numbers - import (Twilio/Telnyx), settings, monitor + web-calls toggles. */
+    readonly phoneNumbers: PhoneNumbers;
+    /** SMS - single sends + bulk campaigns. */
+    readonly sms: Sms;
+    /** API key management - rotate the secret. */
+    readonly keys: Keys;
+    /** Usage + balance. */
+    readonly usage: UsageResource;
+    /** Per-number post-call webhook configuration. */
+    readonly webhooks: Webhooks;
+    constructor(options: NixflexClientOptions);
+    /** Create a brand-new API key (unauthenticated signup endpoint - most
+     * developers use the dashboard instead). The key_secret is shown ONCE.
+     * Rate-limited per IP to prevent abuse. */
+    static createKey(params?: {
+        name?: string;
+        email?: string;
+    }, baseUrl?: string): Promise<KeyCreateResponse>;
+}
+
+export { type Agent, type AgentCreateParams, type AgentDeleteResponse, type AgentUpdateParams, type BatchCampaignParams, type BatchCreateResponse, type BatchInvalidEntry, type BatchLaunchResponse, type BatchRecipient, type Call, type CallDirection, type CallerSentiment, type KeyCreateResponse, type KeyRotateResponse, type ListParams, type MonitorToggleResponse, Nixflex, type NixflexAPIErrorBody, NixflexAuthenticationError, type NixflexClientOptions, NixflexConnectionError, NixflexError, NixflexInvalidRequestError, NixflexNotFoundError, NixflexPaymentRequiredError, NixflexRateLimitError, NixflexServerError, type OutboundCallParams, type OutboundCallResponse, type PhoneNumber, type PhoneNumberDeleteResponse, type PhoneNumberImportParams, type PhoneNumberListResponse, type PhoneNumberUpdateParams, type RequestOptions, type ResponseLength, type SmsCampaign, type SmsCampaignCreateParams, type SmsCampaignDeleteResponse, type SmsCampaignLaunchResponse, type SmsCampaignListResponse, type SmsCampaignRecipient, type SmsCampaignStatus, type SmsSendParams, type SmsSendResponse, type TransferType, type Usage, type WebCallsToggleResponse, type WebhookConfigResponse, type Weekday, Nixflex as default, errorFromResponse };